Classes

• namespace Rodin The Rodin library for Shape and Topology Optimization.
  • namespace Assembly Module for performing the assembly of linear algebra objects from variational expressions.
    • class AssemblyBase Base class template for assembly operations.
    • class AssemblyBase<OperatorType, Variational::BilinearForm<Solution, TrialFES, TestFES, OperatorType>> Base class for bilinear form assembly operations.
    • class AssemblyBase<VectorType, Variational::LinearForm<FES, VectorType>> Base class for linear form assembly operations.
    • class BilinearFormAssemblyInput Input data for bilinear form assembly.
    • class BilinearFormTupleAssemblyInput Input data for tuple of bilinear forms assembly.
    • class Default Default assembly strategy selector.
    • class Default<Context::Local> Default assembly strategy for local context without OpenMP.
    • class Default<Context::Local, Context::Local> Default assembly strategy for mixed local contexts without OpenMP.
    • class DirichletBCAssemblyInput Input data for Dirichlet boundary condition assembly.
    • class Generic Generic problem assembly implementation.
    • class Generic<LinearSystem, Variational::Problem<LinearSystem, TrialFunction, TestFunction>> final Generic assembly implementation for complete variational problems.
    • class LinearFormAssemblyInput Input data for linear form assembly.
    • class LinearFormTupleAssemblyInput Input data for tuple of linear forms assembly.
    • class OpenMP<::Mat, Variational::BilinearForm<Solution, TrialFES, TestFES, ::Mat>> final OpenMP assembly for PETSc Mat (bilinear form)
    • class OpenMP<::Vec, Variational::LinearForm<FES, ::Vec>> final OpenMP assembly for PETSc Vec (linear form)
    • class OpenMP<Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final OpenMP assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class OpenMP<Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>, Variational::LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>>> OpenMP assembly of the Math::Vector associated to a LinearForm object.
    • class OpenMP<std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>, Variational::BilinearForm<Solution, TrialFES, TestFES, std::vector<Eigen::Triplet<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>>> final OpenMP-based parallel assembly for bilinear forms.
    • class OpenMPIteration<Geometry::Mesh<Context::Local>> OpenMP-based parallel mesh iteration for multi-threaded assembly.
    • class ProblemAssemblyInput Input data for complete problem assembly.
    • class Sequential Sequential (single-threaded) assembly implementation.
    • class Sequential<Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::Matrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final Sequential assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class Sequential<Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Variational::BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<typename FormLanguage::Dot<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>>> final Sequential assembly of the Math::SparseMatrix associated to a BilinearFormBase object.
    • class Sequential<Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>, Variational::LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>>> final Sequential assembly implementation for linear forms.
    • class SequentialIteration Sequential mesh iteration strategy.
    • class SequentialIteration<Geometry::Mesh<Context::Local>> Sequential mesh iteration for single-threaded assembly.
  • namespace Context Module for serial, multi-threaded, distributed, and/or parallel computation.
    • class Base Abstract base class for all execution contexts.
    • class Local Represents a single machine context.
    • class MPI MPI context for parallel computing with Message Passing Interface.
  • namespace External Third-party library integrations with Rodin.
    • namespace MFEM MFEM integration with Rodin.
    • namespace MMG MMG integration with Rodin.
      • class ImplicitDomainMesher Class to perform the discretization and optimization of a surface implicitly defined by a level set function.
      • class Mesh Mesh class which has support for MMG functionalities.
        • class Builder Class used to build MMG::Mesh instances.
      • class MeshPrinter Class used to print objects of type MMG::Mesh.
      • class MMG5 Class representing MMG5 objects utilized in the MMG framework.
      • struct NoSplitT Empty class tag to specify that a material reference should not be splitted.
      • class Optimizer Improves the mesh quality, mantaining the mean edge lenghts of the mesh.
      • struct Split Class to specify the interior and exterior material references.
  • namespace FormLanguage Module for writing high level abstract expressions.
    • class Base Base class for all objects in Rodin's FormLanguage system.
    • struct Debug Template for debugging form language types.
    • struct Division Type trait for deducing the result type of division.
    • struct Dot Type trait for deducing the result type of dot product.
    • struct IsEigenObject Type trait to check if a type is an Eigen object.
    • struct IsPlainObject Type trait to identify Eigen plain object types.
    • struct IsPlainObject<Eigen::PlainObjectBase<Derived>> Specialization for Eigen::PlainObjectBase types.
    • class List Container for polymorphic form language objects.
      • class ConstIterator Forward iterator for const List.
      • class Iterator Forward iterator for non-const List.
    • struct Minus Type trait for deducing the result type of subtraction.
    • struct Mult Type trait for deducing the result type of multiplication.
    • struct RangeOf Type trait to deduce the mathematical range type of an expression.
    • struct RangeOf<Boolean> Range type for Boolean values.
    • struct RangeOf<Complex> Range type for Complex values.
    • struct RangeOf<Eigen::Matrix<Scalar, Rows, 1, Options, MaxRows, MaxCols>> Range type for Eigen column vectors.
    • struct RangeOf<Eigen::Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> Range type for Eigen matrices.
    • struct RangeOf<Integer> Range type for Integer values.
    • struct RangeOf<Real> Range type for Real values.
    • struct RangeOf<Variational::FunctionBase<Derived>> Range type for FunctionBase.
    • struct RangeOf<Variational::ShapeFunctionBase<Derived, FES, Space>> Range type for ShapeFunctionBase.
    • struct ResultOf Type trait to deduce the result type of an expression.
    • struct ResultOf<Variational::FunctionBase<Derived>> Specialization of ResultOf for FunctionBase.
    • struct ResultOf<Variational::ShapeFunctionBase<Derived, FES, Space>> Specialization of ResultOf for ShapeFunctionBase.
    • struct Sum Type trait for deducing the result type of addition.
    • struct Traits Type traits for form language objects.
    • struct Traits<Boolean> Traits specialization for Boolean type.
    • struct Traits<Complex> Traits specialization for Complex type.
    • struct Traits<Geometry::Mesh<Context>> Traits specialization for Mesh types.
    • struct Traits<Integer> Traits specialization for Integer type.
    • struct Traits<Real> Traits specialization for Real type.
    • struct Traits<Variational::Potential<LHS, Variational::FunctionBase<RHSDerived>>> Traits for Potential operator.
    • struct Traits<Variational::Potential<LHS, Variational::ShapeFunctionBase<Variational::ShapeFunction<RHSDerived, FES, Space>>>> Traits for Potential.
    • struct UnaryMinus Type trait for deducing the result type of unary negation.
  • namespace Geometry Module for dealing with geometries.
    • namespace Euclidean Module for dealing with Euclidean geometries.
      • class Base Base class for Euclidean geometric objects using CRTP.
      • class Circle Circle in 2D Euclidean space.
      • struct has_connect_method Type trait to detect if a type has a connect method.
      • struct has_connect_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().connect(std::declval<const OtherGeometry&>()))>> Specialization when connect method exists.
      • struct has_distance_method Type trait to detect if a type has a distance method.
      • struct has_distance_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().distance(std::declval<const OtherGeometry&>()))>> Specialization when distance method exists.
      • struct has_intersect_method Type trait to detect if a type has an intersect method.
      • struct has_intersect_method<T, OtherGeometry, std::void_t<decltype(std::declval<T>().intersect(std::declval<const OtherGeometry&>()))>> Specialization when intersect method exists.
      • class Line2D Infinite line in 2D Euclidean space.
      • class LineSegment2D Line segment in 2D Euclidean space.
      • class Point2D Point in 2D Euclidean space.
      • class Rectangle Axis-aligned rectangle in 2D Euclidean space.
    • class AttributeIndex Manages attribute assignments for mesh polytopes.
      • struct Dimension Storage for attributes of polytopes in a single dimension.
    • class BalancedCompactPartitioner Partitioner that creates balanced, spatially compact partitions.
    • class BoundedIndexGenerator final Index generator for a bounded range of indices.
    • class CCL Connected component labeling result.
    • class Cell Represents a cell (highest-dimensional element) in a mesh.
    • class CellIterator Iterator over mesh cells (highest-dimensional polytopes).
    • class Connectivity Template for connectivity information.
    • class Connectivity<Context::Local> final Mesh connectivity for sequential (local) meshes.
      • struct PolytopeIndex Bidirectional index mapping for polytope identification.
      • struct SubPolytope Represents a sub-polytope (lower-dimensional face).
    • class ConnectivityBase Abstract base class for mesh connectivity.
    • class ContainerIndexGenerator Index generator that wraps a container's iterators.
    • class EmptyIndexGenerator final Index generator that represents an empty sequence.
    • class Face Represents a face (codimension-1 element) in a mesh.
    • class FaceIterator Iterator over mesh faces (codimension-1 polytopes).
    • class GeometryIndexed Template container indexed by polytope geometry types.
    • class GreedyPartitioner Partitioner using a greedy algorithm.
    • class IdentityTransformation final Polytope identity transformation.
    • class IndexGeneratorBase Abstract base class for index generators.
    • class IsoparametricTransformation Template for isoparametric transformations.
    • class IteratorIndexGenerator Index generator that wraps an iterator pair.
    • class Mesh Represents a polyhedral complex.
    • class Mesh<Context::Local> Represents the subdivision of some domain into faces of (possibly) different geometries.
      • class Builder Class used to build Mesh<Context::Local> instances.
    • class MeshBase Abstract base class for all mesh implementations.
    • class Partitioner Abstract base class for mesh partitioning strategies.
    • class Point final Concrete implementation of a spatial point on a mesh.
    • class PointBase Base class for spatial points on a discrete mesh.
    • class Polytope Base class for all geometric elements in finite element meshes.
      • struct Project Projection operations for polytope sub-entities.
      • struct Traits Geometric traits for polytope types.
        • struct HalfSpace Half-space representation of reference element.
    • class PolytopeIterator Iterator over general polytopes of specified dimension.
    • class PolytopeIteratorBase Base class template for polytope iterators.
    • class PolytopeTransformation Abstract base class for polytope geometric transformations.
    • class PolytopeTransformationIndex Thread-safe index for managing polytope transformations.
      • struct Dimension Storage for transformations of polytopes in a single dimension.
      • struct Slot Storage slot for a single transformation.
    • class SetIndexGenerator Index generator backed by a set of indices.
    • class Shard Advanced mesh shard for distributed parallel computing.
      • class Builder Builder for constructing Shard instances.
      • class Flags Bitmask flags indicating polytope state.
      • struct PolytopeMap Bidirectional polytope index mapping.
    • class Sharder Interface for mesh sharding algorithms.
    • class Sharder<Context::MPI> Utility for distributing a global mesh across MPI ranks by splitting into per-rank shards, scattering them from a root, and gathering the local mesh on each rank.
    • class SubMesh Represents a subset of a Mesh.
    • class SubMesh<Context::Local> final SubMesh representing a subregion of a parent mesh.
      • class Builder Builder for constructing SubMesh instances.
    • class SubMeshBase Abstract base class for SubMesh implementations.
      • struct PolytopeMap Polytope index mapping structure.
    • class SubMeshBuilder Builder for constructing SubMesh objects.
    • class VectorIndexGenerator Index generator backed by a vector of indices.
    • class Vertex Represents a vertex (0-dimensional element) in a mesh.
    • class VertexIterator Iterator over mesh vertices (0-dimensional polytopes).
  • namespace IO Module for dealing with I/O functionality.
    • class GridFunctionLoader Loader template for grid functions with specific file format.
    • class GridFunctionLoader<FileFormat::MFEM, Variational::P1<Range, Geometry::Mesh<Context::Local>>, Math::Vector<typename FormLanguage::Traits<Range>::ScalarType>> Specialization for loading P1 grid functions from MFEM format.
    • class GridFunctionLoaderBase Base class for loading grid functions from files or streams.
    • class GridFunctionPrinter Printer template for grid functions with specific file format.
    • class GridFunctionPrinter<FileFormat::MFEM, FES, Math::Vector<Scalar>> final Final specialization for printing grid functions with vector data in MFEM format.
    • class GridFunctionPrinterBase Forward declaration of base class for printing grid functions.
    • class GridFunctionPrinterBase<FileFormat::MFEM, Variational::P0<Range, Geometry::Mesh<Context>>, Data> Base class for printing P0 (piecewise constant) grid functions in MFEM format.
    • class GridFunctionPrinterBase<FileFormat::MFEM, Variational::P1<Range, Geometry::Mesh<Context>>, Data> Base class for printing P1 (continuous Lagrange) grid functions in MFEM format.
    • class Loader Base template for loading objects from files or streams.
    • class MeshLoader Loader template for meshes with specific file format and context.
    • class MeshLoader<IO::FileFormat::MEDIT, Context::Local> Specialization for loading Sequential meshes in the MEDIT file format.
    • class MeshLoader<IO::FileFormat::MFEM, Context::Local> Specialization for loading sequential meshes in MFEM format.
    • class MeshLoaderBase Base class for loading meshes from files or streams.
    • class MeshPrinter Printer template for meshes with specific file format and context.
    • class MeshPrinter<FileFormat::ENSIGHT6, Context::Local> Specialization for printing sequential meshes in EnSight6 format.
    • class MeshPrinter<FileFormat::MFEM, Context::Local> Specialization for printing sequential meshes in MFEM format.
    • class MeshPrinterBase Base class for printing meshes to streams or files.
    • class Printer Base template for printing objects to streams.
  • namespace Math Module for general mathematical operations.
    • class LinearSystem Represents a linear system of equations.
    • class LinearSystem<Math::Matrix<MatrixScalar>, Math::Vector<VectorScalar>> Linear system specialization for dense matrices.
    • class LinearSystem<Math::SparseMatrix<MatrixScalar>, Math::Vector<VectorScalar>> Linear system specialization for sparse matrices.
    • class LinearSystemBase Base class for linear systems of the form .
    • class Rad Represents an angle in radians.
    • class Unit Base class for units using CRTP.
  • namespace Models Module which provides implementation of various variational models.
    • namespace Advection Module which provides models for the resolution of unsteady advection equations.
      • class FirstOrderBoundaryPolicy First-order boundary policy for Lagrangian advection.
      • class Lagrangian Lagrangian variational advection for scalar fields.
      • class Lagrangian<Variational::TrialFunction<Variational::GridFunction<FES, Data>, FES>, Variational::TestFunction<FES>, Initial, VectorField, Step> Lagrangian advection specialization for trial/test function formulation.
    • namespace Distance Module which provides models for computation of the distance function.
      • class Base Base class for distance function computation models using CRTP.
      • class Eikonal Distance function computation using the Eikonal equation.
      • class Poisson Poisson approximation to the distance function.
      • class Rvachev Rvachev normalization for a level set function.
      • class SignedPoisson Poisson approximation to the signed distance function.
      • class SpaldingTucker Spalding-Tucker normalization for a level set function.
    • namespace Eikonal Module which provides solvers for the Eikonal equation.
      • class FMM Fast marching method for solving the Eikonal equation.
      • class FMM<Variational::GridFunction<Variational::P1<Real, Geometry::Mesh<Context::Local>>, Data>, SpeedFunction> FMM specialization for P1 finite elements on local meshes.
    • namespace Elasticity Module which provides models for solid mechanics and elasticity.
      • class LinearElasticity Linear elasticity system for small deformations.
    • namespace Hilbert Module which provides models and tools for the Hilbertian extension-regularization procedure.
      • class H1a Hilbertian extension-regularization procedure with a regularization length-scale parameter.
  • namespace Plot Module for visualization tools.
    • namespace Artist Module for Rodin::Plot artists.
      • namespace Axes Contains artist functionality for Axes.
      • namespace Axis Contains artist functionality for Axis.
      • namespace Lines Contains artist functionality for Lines.
      • class Figure Represents a figure plot.
    • namespace Backend Module for the Rodin::Plot backend.
      • namespace Bases Contains base backend functionality.
        • class BaseArtist2D Base class for artists in 2D.
        • class BaseDrawable2D Base class for drawables.
        • class BaseFigure Base class for figures.
      • namespace Event Contains backend event functionality.
      • namespace Renderer Contains backend renderer functionality.
        • namespace Drawables Contains backend renderer for drawables.
        • class Camera2D Represents a camera in 2D.
    • namespace GUI Contains GUI functionality.
    • class Configuration Represents the configuration parameters to use for plotting.
    • class Plot Main plotting interface for finite element visualization.
  • namespace QF Module for defining quadrature formulae.
    • class Centroid final Single-point centroid quadrature formula.
    • class GaussLegendre final Gauss-Legendre quadrature formula on reference polytopes.
    • class GaussLobatto final Gauss-Lobatto quadrature formula on reference polytopes.
    • class GenericPolytopeQuadrature Generic quadrature formula dispatcher for all polytope types.
    • class GrundmannMoller Grundmann-Möller simplex quadrature formula.
    • class QuadratureFormulaBase Abstract base class for quadrature formulas.
  • namespace Solver Module for linear algebra systems.
    • class BiCGSTAB Bi-conjugate gradient stabilized iterative solver.
    • class BiCGSTAB<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Bi-conjugate gradient stabilized solver for non-symmetric sparse systems.
    • class CG Conjugate gradient solver for symmetric positive definite systems.
    • class CG<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Conjugate gradient solver for symmetric positive definite dense systems.
    • class CG<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Conjugate gradient solver for symmetric positive definite sparse systems.
    • class CG<PETSc::Math::LinearSystem> final Conjugate gradient solver for self-adjoint problems, for use with PETSc::Matrix and PETSc::Vector.
    • class DGMRES Deflated generalized minimal residual iterative solver.
    • class EigenSolver Wrapper class for any Eigen sparse solver.
    • class GMRES Generalized minimal residual iterative solver.
    • class HouseholderQR Householder QR decomposition for dense matrices.
    • class HouseholderQR<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final A direct sparse HouseholderQR Cholesky factorizations without square root for use with Math::SparseMatrix and Math::Vector.
    • class IDRSTABL IDR(s)STABL iterative solver.
    • class KSP PETSc KSP (Krylov) linear solver wrapper.
    • class LDLT Robust LDLT Cholesky decomposition for dense matrices.
    • class LDLT<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Robust LDLT Cholesky factorization with pivoting for dense matrices.
    • class LeastSquaresCG Least-squares conjugate gradient solver.
    • class LeastSquaresCG<Math::LinearSystem<Math::Matrix<Scalar>, Math::Vector<Scalar>>> final Least-squares conjugate gradient solver for dense systems.
    • class LeastSquaresCG<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Least-squares conjugate gradient solver for sparse systems.
    • class SimplicialLDLT Direct sparse LDLT Cholesky factorization solver.
    • class SimplicialLDLT<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Simplicial LDLT Cholesky factorization without square root.
    • class SimplicialLLT Direct sparse LLT Cholesky factorization solver.
    • class SimplicialLLT<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Simplicial LLT Cholesky factorization for sparse SPD matrices.
    • class SolverBase Abstract base class for linear system solvers.
    • class SparseLU Sparse supernodal LU factorization for general matrices.
    • class SparseLU<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Sparse supernodal LU factorization solver for general sparse matrices.
    • class SparseQR Sparse QR factorization with column pivoting.
    • class SparseQR<Math::LinearSystem<Math::SparseMatrix<Scalar>, Math::Vector<Scalar>>> final Sparse QR factorization with numerical column pivoting.
  • namespace Test Module containing various utilities and classes for writing tests.
  • namespace Tests Tests of the Rodin library
    • namespace Benchmarks Performance benchmarks.
    • namespace Manufactured Manufactured solution test cases
      • namespace Conductivity Manufactured solutions for the conductivity problem using P1 spaces.
      • namespace Darcy Manufactured solution for the Darcy problem using P1 spaces.
      • namespace DivPoisson Manufactured solutions for the divergence Poisson problem using P1 vector spaces.
      • namespace LinearElasticity Manufactured solutions for the linear elasticity problem.
      • namespace Poisson Manufactured solutions for the Poisson problem.
      • namespace ReactionDiffusion Manufactured solutions for a coupled system of two reaction–diffusion equations.
    • namespace Unit Unitary tests.
      • class FlowTest Unit tests for Flow class basic functionality.
      • class FMMTest Basic unit tests for Fast Marching Method (FMM)
      • class LagrangianTest Unit tests for Lagrangian class basic functionality.
  • namespace Threads Module containing various tools for working with threads.
  • namespace Traits Module containing metaprogramming facilities.
  • namespace Utility Module containing general purpose and language support utility classes.
    • struct BottomTemplate Metafunction to extract the innermost (bottom) type from nested templates.
    • struct BottomTemplate<T<S>> Specialization for single-parameter template instantiations.
    • class Cast Template for defining type conversion operations.
    • struct DependentValue Creates a type-dependent compile-time constant value.
    • struct Extract Template metafunction for extracting types from tuple structures.
    • struct Extract<Tuple<T, Ts...>> Specialization of Extract for Tuple types.
    • struct HasTypeMember Type trait to detect if a type has a nested Type member.
    • struct HasTypeMember<T, std::void_t<typename T::Type>> Specialization for types that have a nested Type member.
    • struct HasValueMember Type trait to detect if a type has a nested Value member type.
    • struct HasValueMember<T, std::void_t<typename T::Value>> Specialization for types that have a nested Value member type.
    • class IntegerSequence Represents a compile-time sequence of integers.
    • struct IsOneOf Type trait to check if a type is one of a specified list of types.
    • struct IsOneOf<F, S, T...> Specialization for non-empty type lists.
    • struct IsSpecialization Type trait to check if a type is a specialization of a given template.
    • struct IsSpecialization<Ref<Args...>, Ref> Specialization for types that are specializations of the reference template.
    • struct Make Factory template for perfect forwarding construction.
    • class OptionalReference A wrapper providing optional reference semantics.
    • struct Overloaded Helper type for creating overloaded function objects from lambdas.
    • class ParameterPack Template metaprogramming utilities for parameter packs.
    • struct Product Metafunction to compute the Cartesian product of two Tuple type-lists.
    • struct Product<Tuple<Gs...>, Tuple<>> Specialization for empty second Tuple.
    • struct Product<Tuple<H>, Tuple<Gs...>> Specialization for Tuple with exactly one element.
    • struct Product<Tuple<H1, H2, Hs...>, Tuple<Gs...>> Specialization for Tuple with at least two elements (H1, H2, Hs…).
    • struct Product<Tuple<>, Tuple<Gs...>> Specialization for empty first Tuple.
    • struct Repeat Metafunction to create a Tuple with N repetitions of type T.
    • struct Repeat<0, T> Specialization for N = 0.
    • struct Repeat<1, T> Specialization for N = 1.
    • struct UnwrapRefDecay Combines decay and reference unwrapping.
    • struct UnwrapReference Metafunction to unwrap std::reference_wrapper types.
    • struct UnwrapReference<std::reference_wrapper<U>> Specialization for std::reference_wrapper.
    • class Wrap Metafunction to wrap all types in a Tuple with an external template.
    • class Wrap<Tuple<Ts...>> Specialization for Tuple types.
    • struct Zip Metafunction to combine two Tuples element-wise using a binary template.
    • struct Zip<Tuple<Ts...>, Tuple<Gs...>> Specialization for two Tuples.
  • namespace Variational Module which provides the necessary tools for constructing variational problems.
    • namespace F Contains built-in coordinate functions.
      • class X First coordinate projection function.
      • class Y Second coordinate projection function.
      • class Z Third coordinate projection function.
    • class Abs Represents the absolute value of a value.
    • class Abs<FunctionBase<NestedDerived>> Absolute value operation for functions.
    • class AND Represents the logical AND expression.
    • class AND<BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>> final Logical AND operator between two boolean functions.
    • class Average<FunctionBase<FunctionDerived>> final Average operator for computing interface averages.
    • class BilinearForm Represents a bilinear form on a trial and test space.
    • class BilinearForm<Solution, TrialFES, TestFES, Math::SparseMatrix<Scalar>> final Speciallization of BilinearForm for a matrix type.
    • class BilinearFormBase Base class for bilinear form representations.
    • class BilinearFormIntegratorBase Abstract base class for bilinear form integrators.
    • class BooleanFunction
    • class BooleanFunctionBase Base class for boolean-valued functions.
    • class BoundaryIntegral Represents expressions of the integral operator on the boundary of a domain.
    • class BoundaryIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class BoundaryIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class BoundaryNormal final Outward unit normal vector on domain boundaries.
    • class ComplexFunction
    • class ComplexFunction<Complex> final Represents a constant scalar function with type Complex.
    • class ComplexFunction<F> final Represents a scalar function given by an arbitrary scalar function.
    • class ComplexFunctionBase Base class for complex-valued scalar functions.
    • class Component<FunctionBase<OperandDerived>, size_t> final Extracts a single component from a vector-valued function.
    • class Component<FunctionBase<OperandDerived>, size_t, size_t> final Extracts a single entry from a matrix-valued function.
    • class Component<GridFunction<FES, Data>> final Extracts a component from a vector-valued GridFunction.
    • class Component<ShapeFunctionBase<OperandDerived, FES, Space>> final Extracts a component from a vector-valued ShapeFunction.
    • class Composition
    • class Conjugate<FunctionBase<NestedDerived>> Complex conjugate of a function.
    • class Conjugate<ShapeFunctionBase<NestedDerived, FES, Space>> final Specialization for shape functions.
    • class Cos Represents the cosine function.
    • class Cos<FunctionBase<NestedDerived>> final Cosine function operator for real-valued scalar functions.
    • class Cosh<FunctionBase<NestedDerived>> final Hyperbolic cosine function operator for real-valued scalar functions.
    • class DefaultBoundaryPolicy Default boundary policy for flow maps.
    • class DefaultTangentPolicy Default tangent policy for flow maps.
    • class DenseProblem<LinearSystem, U, V> General class to assemble linear systems with Math::Matrix and Math::Vector types in a serial context.
    • class Derivative<GridFunction<P1<Range, Mesh>, Data>> final Derivative of a P1 GridFunction.
    • class DerivativeBase Base class for directional derivative operators.
    • class DirichletBC
    • class DirichletBC<TrialFunction<Solution, FES>, FunctionBase<ValueDerived>> final Represents a Dirichlet boundary condition on a ShapeFunction object.
    • class DirichletBCBase Abstract base class for a Dirichlet boundary condition.
    • class Div Represents the divergence of a vector valued function.
    • class Div<GridFunction<P1<Math::Vector<Scalar>, Mesh>, Data>> final Divergence of a P1 vector GridFunction.
    • class Div<ShapeFunction<NestedDerived, P1<Math::Vector<Number>, Mesh>, Space>> final Divergence of a P1 vector ShapeFunction.
    • class DivBase Base class for divergence operator implementations.
    • class DivBase<GridFunction<FES, Data>, Derived> Divergence of a P1 GridFunction.
    • class Division Represents the division operation.
    • class Division<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> Division of a function by another function.
    • class Dot Represents the dot product between two objects.
    • class Dot<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Dot product between two functions.
    • class Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, FES, Space>> final Dot product between a function and a shape function.
    • class Dot<Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>> Dot product of a potential with a test shape function.
    • class Dot<ShapeFunctionBase<LHSDerived, FES, Space>, FunctionBase<RHSDerived>> final Dot product between a shape function and a function.
    • class Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>> final Dot product of trial and test shape functions for bilinear forms.
    • class DubinerTetrahedron Dubiner orthogonal modal basis on the reference tetrahedron.
    • class DubinerTriangle Dubiner orthogonal modal basis on the reference triangle.
    • class EQ
    • class EQ<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Logical EQ operator between two instances of FunctionBase.
    • class Exp<FunctionBase<NestedDerived>> Exponential function operation.
    • class FaceIntegral Represents expressions of the integral operator on the faces of a mesh.
    • class FaceIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class FaceIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class FaceNormal Unit normal vector on mesh faces.
    • class FeketeTetrahedron Cached Fekete-type nodes on the reference tetrahedron for degree K.
    • class FeketeTriangle Cached Fekete-type nodes on the reference triangle for degree K.
    • class FiniteElementBase Base class for finite elements.
    • class FiniteElementSpace Represernts a finite element space.
    • class FiniteElementSpace<Geometry::Mesh<Context::MPI>, Derived> Represernts a finite element space.
    • class FiniteElementSpaceBase Base class for finite element spaces.
      • struct LocalIndex Local degree of freedom indexing structure.
    • class FiniteElementSpacePullbackBase Base class for mappings taking functions defined on physical elements to reference elements.
    • class FiniteElementSpacePushforwardBase Base class for inverse mappings taking functions defined on reference elements to physical elements.
    • class Flow<FunctionBase<Derived>, VectorField, Step, BoundaryPolicy, TangentPolicy> Flow map operator for functions.
    • class Frobenius Represents the Frobenius norm.
    • class Frobenius<FunctionBase<NestedDerived>> Frobenius norm of a function.
    • class FunctionBase Base class for function objects which can be evaluated over a mesh.
    • class FunctionBaseCopy
    • class GEQ
    • class GLL Compile-time Gauss–Lobatto–Legendre (GLL) nodes on [-1, 1].
    • class GLL01 Gauss–Lobatto–Legendre nodes mapped from [-1, 1] to [0, 1].
    • class Grad Represents the gradient of a scalar function .
    • class Grad<GridFunction<P0<Range, Mesh>, Data>> final Gradient of a P0 GridFunction.
    • class Grad<ShapeFunction<NestedDerived, P0<Scalar, Mesh>, SpaceType>> final Gradient of a P0 ShapeFunction.
    • class Grad<ShapeFunction<NestedDerived, P1<Scalar, Mesh>, SpaceType>> final Gradient of a ShapeFunction.
    • class GradBase Base class for gradient operator implementations.
    • class GradBase<GridFunction<FES, Data>, Derived> Gradient operator for grid functions.
    • class GridFunction Represents a grid function belonging to some finite element space.
    • class GridFunctionBase Base class for grid function objects.
    • class GridFunctionBaseReference Base class for discrete finite element functions.
    • class GT
    • class H1 Degree K H1-conforming Lagrange finite element space.
    • class H1<K, Math::Vector<Scalar>, Geometry::Mesh<Context::Local>> final Vector-valued continuous piecewise polynomial (degree K) Lagrange finite element space.
    • class H1<K, Scalar, Geometry::Mesh<Context::Local>> Degree K H1-conforming Lagrange finite element space.
      • class Cochain Local cochain map for H1 DOF injection from boundary to element.
      • class Pullback Pullback for the scalar/complex H1 space.
      • class Pushforward Inverse Pullback for the scalar/complex H1 space.
    • class H1Element Degree k H1-conforming Lagrange element.
      • class BasisFunction Represents a Lagrange basis function of degree K.
        • class DerivativeFunction Represents a partial derivative of a basis function.
        • class GradientFunction Represents the gradient of a basis function.
      • class LinearForm Evaluates linear form at a given function/vector field.
    • class H1Element<K, Math::Vector<Scalar>> final Continuous H1-conforming piecewise polynomial (degree k) vector Lagrange element.
    • class IdentityMatrix Represents the identity matrix function .
    • class Im Extracts the imaginary part of a complex-valued function.
    • class Im<FunctionBase<NestedDerived>> Specialization for FunctionBase operands.
    • class IntegerFunction
    • class IntegerFunctionBase Base class for objects representing integer functions.
    • class Integral Represents mathematical expressions of the integral operator on a domain.
    • class Integral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class Integral<GridFunction<FES, Data>> final Integration of a GridFunction object.
    • class Integral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • class Integrator Abstract base class for integrators in variational formulations.
    • class InterfaceIntegral Represents expressions of the integral operator on the interface of a domain.
    • class InterfaceIntegral<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> final Integration of the dot product of a trial and test operators.
    • class InterfaceIntegral<ShapeFunctionBase<NestedDerived, FES, TestSpace>> final Integration of a test operator.
    • struct IsTestFunction Type trait to check if a type is a TestFunction.
    • struct IsTestFunction<TestFunction<FES>> Specialization for TestFunction types.
    • struct IsTrialFunction Type trait to check if a type is a TrialFunction.
    • struct IsTrialFunction<TrialFunction<Solution, FES>> Specialization for TrialFunction types.
    • class Jacobian Represents the Jacobian matrix of a type.
    • class Jacobian<GridFunction<P1<Range, Mesh>, Data>> final Jacobian of a P1 vector GridFunction.
    • class Jacobian<ShapeFunction<ShapeFunctionDerived, P1<Range, Mesh>, Space>> final Jacobian of an P1 ShapeFunction object.
    • class JacobianBase Base class for Jacobian matrix operator implementations.
    • class JacobianBase<GridFunction<FES, Data>, Derived> Jacobian of a P1 GridFunction.
    • class JacobiPolynomial Jacobi polynomial evaluator.
    • class L2 Arbitrary order broken Sobolev space.
    • class LagrangeBasis1D Generic 1D Lagrange basis on arbitrary nodes.
    • class LagrangeBasisPoint Lagrange basis on the reference point (0D element).
    • class LagrangeBasisQuadrilateral Lagrange basis on the reference quadrilateral [0,1]².
    • class LagrangeBasisSegment Lagrange basis on the reference segment [0,1] using GLL nodes.
    • class LagrangeBasisTetrahedron Lagrange basis on the reference tetrahedron.
    • class LagrangeBasisTriangle Lagrange basis on the reference triangle.
    • class LagrangeBasisWedge Lagrange basis on the reference wedge (triangular prism).
    • class LegendrePolynomial Compile-time degree Legendre polynomial evaluator.
    • class LEQ
    • class LinearElasticityIntegral final Helper class to construct linear elasticity integrators.
    • class LinearElasticityIntegrator final Bilinear form integrator for linear elasticity.
    • class LinearElasticityIntegrator<Solution, P1<Range, Mesh>, MuDerived, LambdaDerived> final P1 linear elasticity bilinear form integrator.
    • class LinearForm Represents a linear form on some finite element space.
    • class LinearForm<FES, Math::Vector<typename FormLanguage::Traits<FES>::ScalarType>> final Represents a linear form defined over some finite element space.
    • class LinearFormBase Base class for linear form objects.
    • class LinearFormIntegratorBase Base class for linear form integrators.
    • class LT
    • class MatrixFunction
    • class MatrixFunctionBase Base class for matrix-valued functions defined on a mesh.
    • class Max<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Represents the maximum operation between two functions.
    • class Min<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Represents the minimum operation between two functions.
    • class Mult Represents the multiplication operation.
    • class Mult<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Multiplication of two FunctionBase instances.
    • class Mult<FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, FES, Space>> final Left Multiplication of a ShapeFunctionBase by a FunctionBase.
    • class Mult<ShapeFunctionBase<LHSDerived, FES, Space>, FunctionBase<RHSDerived>> final Right multiplication of a ShapeFunctionBase by a FunctionBase.
    • class NEQ
    • class OR
    • class OR<BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>> final Logical OR operator between two instances of BooleanFunctionBase.
    • class P0 Degree 0 Lagrange finite element space.
    • class P0<Real, Geometry::Mesh<Context::Local>> final Scalar-valued piecewise constant (P0) Lagrange finite element space.
    • class P0Element Degree 0 Lagrange element.
      • class BasisFunction Represents the constant basis function of a P0 scalar element.
        • class DerivativeFunction Represents a derivative of the P0 basis function (always zero).
      • class LinearForm Represents a linear form of a P0 scalar element.
    • class P0Element<Math::Vector<Scalar>> final Piecewise constant (degree 0) vector Lagrange element.
      • class BasisFunction Represents a piecewise constant vector basis function.
        • class DerivativeFunction Represents a derivative of the vector P0 basis function (always zero).
      • class LinearForm Represents a linear form (evaluation functional) for vector P0 elements.
    • class P1 Degree 1 Lagrange finite element space.
    • class P1<Math::Vector<Scalar>, Geometry::Mesh<Context::Local>> final Vector-valued continuous piecewise linear Lagrange finite element space.
    • class P1<Scalar, Geometry::Mesh<Context::Local>> Real valued Lagrange finite element space.
      • class Pullback Pullback for the scalar/complex P1 space.
      • class Pushforward Inverse Pullback for the scalar/complex P1 space.
    • class P1Element Degree 1 Lagrange element.
      • class BasisFunction Represents a piecewise linear basis function of a P1 scalar element.
        • class DerivativeFunction Represents a partial derivative of a P1 basis function.
        • class GradientFunction Represents the gradient of a P1 basis function.
      • class LinearForm Represents a linear form of a P1 scalar element.
    • class P1Element<Math::Vector<Scalar>> final Continuous piecewise linear (degree 1) vector Lagrange element.
    • class PeriodicBC<TrialFunction<Solution, FES>, IndexMap<IndexSet>> final Represents a Peridodic boundary condition on a ShapeFunction object.
    • class PeriodicBCBase Abstract base class for a periodic boundary condition.
    • class Potential<LHS, ShapeFunctionBase<ShapeFunction<RHSDerived, FES, SpaceType>, FES, SpaceType>> final
    • class Pow Represents the power function.
    • class Pow<FunctionBase<BaseDerived>, Number> final Represents the power function.
    • class Problem Represents a variational problem.
    • class ProblemBase Base class for variational problem objects.
    • class ProblemBodyBase Base class representing the body of a variational problem.
    • class ProblemUVBase General class to assemble linear systems with Operator and Vector generic types in a sequential context.
    • class QuadratureRule
    • class QuadratureRule<Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the isotropic Dot product of two instances of the P1 Grad of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the isotropic Frobenius inner product two instances of the P1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>> Approximation of the integral of the the dot product between a trial shape function and a test shape function.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Dot product of two instances of the P1 Grad of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Frobenius inner product two instances of the P1 Jacobian of ShapeFunction.
    • class QuadratureRule<Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, P1<LHSRange, LHSMesh>, TrialSpace>, P1<LHSRange, LHSMesh>, TrialSpace>>, P1<LHSRange, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<RHSRange, RHSMesh>, TestSpace>, P1<RHSRange, RHSMesh>, TestSpace>>> Integration of the anisotropic Dot product of two instances of the P1 ShapeFunction.
    • class QuadratureRule<FunctionBase<FunctionDerived>> final Quadrature rule for integrating functions on mesh polytopes.
    • class QuadratureRule<GridFunction<FES, Data>> Integration of a GridFunction object.
    • class QuadratureRule<ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>, P1<Range, Mesh>, TestSpace>>, P1<Range, Mesh>, TestSpace>> Integration of the Dot product of some coefficient function and a P1 ShapeFunction.
    • class QuadratureRule<ShapeFunctionBase<NestedDerived, FES, TestSpace>> Approximation of the integral of a test shape function.
    • class QuadratureRule<ShapeFunctionBase<ShapeFunction<NestedDerived, P1<Range, Mesh>, TestSpace>, P1<Range, Mesh>, TestSpace>> Integration of a P1 ShapeFunction.
    • class Re Extracts the real part of a complex-valued function.
    • class Re<FunctionBase<NestedDerived>> Specialization for FunctionBase operands.
    • class RealFunction
    • class RealFunction<F> final Represents a scalar function given by an arbitrary scalar function.
    • class RealFunction<Real> final Represents a constant scalar function with type Real.
    • class RealFunctionBase Base class for real-valued functions defined on a mesh.
    • class RelativeError Utility class for computing relative errors.
    • class ScalarFunctionBase Base class for scalar-valued functions with templated scalar type.
    • class ShapeFunction Intermediate shape function class for CRTP derivation.
    • class ShapeFunctionBase Base class for shape function objects.
    • class Sin<FunctionBase<NestedDerived>> final Sine function operator for real-valued scalar functions.
    • class Sinh<FunctionBase<NestedDerived>> final Hyperbolic sine function operator for real-valued scalar functions.
    • class SparseProblem<TrialFES, TestFES, Math::Matrix<typename FormLanguage::Mult<typename FormLanguage::Traits<TrialFES>::ScalarType, typename FormLanguage::Traits<TestFES>::ScalarType>::Type>, Math::Vector<typename FormLanguage::Traits<TestFES>::ScalarType>> General class to assemble linear systems with Math::SparseMatrix and Math::Vector types in a serial context.
    • class Sqrt<FunctionBase<NestedDerived>> final Square root operation for functions.
    • class Sum Represents the sum operation.
    • class Sum<FunctionBase<LHSDerived>, FunctionBase<RHSDerived>> final Addition of two functions.
    • class Sum<ShapeFunctionBase<LHSDerived, FES, Space>, ShapeFunctionBase<RHSDerived, FES, Space>> final Addition of two shape functions.
    • class Tan Represents the tangent function.
    • class Tan<FunctionBase<NestedDerived>> Tangent function operator for real-valued scalar functions.
    • class TestFunction Represents a function which belongs to a test space.
    • class TetrahedronBlend Optimized blending parameter α for tetrahedral warp-blend.
    • class Trace Represents the trace of a matrix function.
    • class Trace<FunctionBase<NestedDerived>> final Trace of a FunctionBase instance.
    • class TraceOperator<FunctionBase> Trace (boundary restriction) operator for functions.
    • class Transpose Represents the transpose matrix of some matrix .
    • class Transpose<FunctionBase<NestedDerived>> final Transpose of a matrix-valued function.
    • class Transpose<ShapeFunctionBase<NestedDerived, FES, Space>> final Transpose of a matrix-valued ShapeFunction.
    • class TrialFunction Represents a function which belongs to a trial space.
    • class TrialFunctionReference Reference wrapper for trial functions.
    • class TriangleBlend Optimized blending parameter α for triangular warp-blend.
    • class UnaryMinus Represent the negation of an operand.
    • class UnaryMinus<FormLanguage::List<LinearFormIntegratorBase<Number>>> Negation of a list of linear form integrators.
    • class UnaryMinus<FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>> Negation of a list of bilinear form integrators.
    • class UnaryMinus<FunctionBase<NestedDerived>> final Negation of a function.
    • class UnaryMinus<LinearFormIntegratorBase<Number>> final Negation of a linear form integrator.
    • class UnaryMinus<LocalBilinearFormIntegratorBase<Number>> Negation of a bilinear form integrator.
    • class UnaryMinus<ShapeFunctionBase<NestedDerived, FES, Space>> final Negation of a shape function.
    • class VandermondeTriangle Vandermonde matrix for nodal-to-modal transformation on triangles.
    • class VectorFunction
    • class VectorFunction<V, Values...> final Represents a vector function which may be constructed from values which can be converted to objects of type RealFunction.
    • class VectorFunctionBase Base class for vector-valued functions defined on a mesh.
    • class WarpBlendTetrahedron Applies warp-blend algorithm to move tetrahedron nodes toward Fekete positions.
    • class WarpBlendTriangle Applies warp-blend algorithm to move triangle nodes toward Fekete positions.
    • class WarpFactor1D Computes the 1D warp factor for moving equispaced nodes to GLL positions.
    • class WarpShiftFace2D Computes 2D warp-blend shift for a triangular face.
    • class WarpShiftFace3D Computes 3D warp-blend shift for a tetrahedral face.
    • class Zero<Math::Vector<Scalar>> final Vector zero function.
    • class Zero<Scalar> final Scalar zero function.
  • class Cast Template class for type casting operations.
  • class Copyable Abstract base class for objects that can be copied.
  • struct DefaultSentinelT Sentinel type for default-constructed iterators.
  • struct IndexArrayEquality Functor for comparing two index arrays for equality.
  • struct IndexArrayHash Functor for computing a hash value for an index array.
  • struct IndexArraySymmetricEquality Functor for comparing two index arrays for symmetric equality.
  • struct IndexArraySymmetricHash Functor for computing a symmetric hash value for an index array.
  • struct IndexSetEquality Functor for comparing two IndexSet objects for equality.
  • struct IndexSetHash Functor for computing a hash value for an IndexSet.
  • class Moveable Abstract base class for objects that can be moved.
  • class Pair Forward declaration of the Pair template class.
  • class Tuple Forward declaration of the Tuple template class.
  • class Tuple<T, Ts...> A tuple class that extends std::tuple with additional functionality.
  • class Tuple<> Specialization of Tuple for an empty parameter pack.