Rodin::FormLanguage namespace

Directory src/Rodin/FormLanguage

Module for writing high level abstract expressions.

The FormLanguage module provides the expression template infrastructure underlying Rodin's variational form language. It enables composing mathematical expressions that are lazily evaluated during assembly.

Key Classes

FormLanguage::Base — Root base class for all form language objects. Provides unique identification (UUID), object lifetime management via shared ownership, and polymorphic copy(). Not thread-safe: use thread_local caching for per-thread output in evaluation methods.
FormLanguage::Traits<T> — Type trait template. Each form language type provides a specialization defining associated types (ScalarType, RangeType, FESType, etc.). Always specialize Traits for new types.
FormLanguage::List — Container for variational form components (integrals, boundary conditions) that makes up the body of a Problem.

Expression Template Pattern

Operators like Grad, Div, Dot are CRTP-based expression templates:

auto stiffness = Integral(Grad(u), Grad(v)); // expression, not yet evaluated
auto load = Integral(f, v);                   // another expression
Problem p(u, v);
p = stiffness - load + DirichletBC(u, Zero()); // combined expression

Expressions store operands via std::reference_wrapper (non-owning) or std::unique_ptr (owning, for temporaries). No computation occurs until assembly iterates over mesh cells and evaluates the expression at quadrature points.

Object Lifetime

The Base::object() helpers manage temporary object lifetimes. When an expression captures a temporary (e.g. a lambda-constructed RealFunction), the temporary is stored in a shared_ptr table within the expression, ensuring it lives as long as the expression does.

Classes

class Base: Base class for all objects in Rodin's FormLanguage system.
template<class T, class = void> struct ColsAtCompileTime: Compile-time column count of a type; -1 when unavailable.
template<class T> struct ColsAtCompileTime<T, std::void_t<decltype(std::decay_t<T>::ColsAtCompileTime)>>: Compile-time column count for Eigen-like types exposing ColsAtCompileTime.
template<typename> struct Debug: Template for debugging form language types.
template<class LHS, class RHS> struct Division: Type trait for deducing the result type of division.
template<class LHS, class RHS> struct Dot: Type trait for deducing the result type of dot product.
template<class T> struct IsEigenObject: Type trait to check if a type is an Eigen object.
template<class T> struct IsMatrixRange: Type trait: whether T has matrix range (a spatial matrix or a multi-column Eigen object).
template<class T> struct IsPlainObject: Type trait to identify Eigen plain object types.
template<class Derived> struct IsPlainObject<Eigen::PlainObjectBase<Derived>>: Specialization for Eigen::PlainObjectBase types.
template<class T> struct IsSpatialMatrix: Type trait: whether T is a Math::SpatialMatrix.
template<class Scalar> struct IsSpatialMatrix<Math::SpatialMatrix<Scalar>>: Type trait specialization for Math::SpatialMatrix.
template<class T> struct IsSpatialVector: Type trait: whether T is a Math::SpatialVector.
template<class Scalar> struct IsSpatialVector<Math::SpatialVector<Scalar>>: Type trait specialization for Math::SpatialVector.
template<class T, class Enable = void> struct IsSpecialized: Whether T is an optimized specialization rather than a generic handler.
template<class T> struct IsSpecialized<T, std::void_t<decltype(T::Specialized)>>: Specialization for types declaring a Specialized member.
template<class T> struct IsVectorRange: Type trait: whether T has vector range (a spatial vector or a single-column Eigen object).
template<class T> class List: Container for polymorphic form language objects.
template<class LHS, class RHS> struct Minus: Type trait for deducing the result type of subtraction.
template<class LHS, class RHS> struct Mult: Type trait for deducing the result type of multiplication.
template<class T> struct RangeKindOf: Deduces the RangeKind of a type T.
template<class MatrixXpr> struct RangeOf: Type trait to deduce the mathematical range type of an expression.
template<> struct RangeOf<Boolean>: Range type for Boolean values.
template<> struct RangeOf<Complex>: Range type for Complex values.
template<class Scalar, int Rows, int Options, int MaxRows, int MaxCols> struct RangeOf<Eigen::Matrix<Scalar, Rows, 1, Options, MaxRows, MaxCols>>: Range type for Eigen column vectors.
template<class Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols> struct RangeOf<Eigen::Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>: Range type for Eigen matrices.
template<> struct RangeOf<Integer>: Range type for Integer values.
template<class Scalar> struct RangeOf<Math::SpatialMatrix<Scalar>>: Range type deduced for Math::SpatialMatrix.
template<class Scalar> struct RangeOf<Math::SpatialVector<Scalar>>: Range type deduced for Math::SpatialVector.
template<> struct RangeOf<Real>: Range type for Real values.
template<class Derived> struct RangeOf<Variational::FunctionBase<Derived>>: Range type for FunctionBase.
template<class Derived, class FES, Variational::ShapeFunctionSpaceType Space> struct RangeOf<Variational::ShapeFunctionBase<Derived, FES, Space>>: Range type for ShapeFunctionBase.
template<class T> struct ResultOf: Type trait to deduce the result type of an expression.
template<class Derived> struct ResultOf<Variational::FunctionBase<Derived>>: Specialization of ResultOf for FunctionBase.
template<class Derived, class FES, Variational::ShapeFunctionSpaceType Space> struct ResultOf<Variational::ShapeFunctionBase<Derived, FES, Space>>: Specialization of ResultOf for ShapeFunctionBase.
template<class LHS, class RHS> struct Sum: Type trait for deducing the result type of addition.
template<class ... Args> struct Traits: Type traits for form language objects.
template<> struct Traits<Boolean>: Traits specialization for Boolean type.
template<> struct Traits<Complex>: Traits specialization for Complex type.
template<class Context> struct Traits<Geometry::Mesh<Context>>: Traits specialization for Mesh types.
template<> struct Traits<Integer>: Traits specialization for Integer type.
template<class Number, size_t S> struct Traits<Math::FixedSizeVector<Number, S>>: Type traits for a Math::FixedSizeVector: exposes the scalar type and the compile-time size.
template<class Operator, class Vector> struct Traits<Math::LinearSystem<Operator, Vector>>: Type traits for a Math::LinearSystem: exposes the operator, vector, and scalar types.
template<class Number> struct Traits<Math::Matrix<Number>>: Type traits for a dense Math::Matrix: exposes the scalar type.
template<class Number> struct Traits<Math::SparseMatrix<Number>>: Type traits for a Math::SparseMatrix: exposes the scalar type.
template<class Number> struct Traits<Math::Vector<Number>>: Type traits for a dynamic Math::Vector: exposes the scalar type.
template<class FES> struct Traits<PETSc::Variational::GridFunction<FES>>: Form-language traits specialization for PETSc grid functions.
template<class FES> struct Traits<PETSc::Variational::TestFunction<FES>>: Form-language traits specialization for PETSc test functions.
template<class Solution, class FES> struct Traits<PETSc::Variational::TrialFunction<Solution, FES>>: Form-language traits specialization for PETSc trial functions.
template<> struct Traits<Real>: Traits specialization for Real type.
template<class LinearSystem> struct Traits<Solver::BiCGSTAB<LinearSystem>>: Form-language traits for BiCGSTAB solvers.
template<class LinearSystem> struct Traits<Solver::CG<LinearSystem>>: Form-language traits for CG solvers.
template<class LinearSystem> struct Traits<Solver::DGMRES<LinearSystem>>: Form-language traits for DGMRES solvers.
template<class LinearSystem> struct Traits<Solver::GMRES<LinearSystem>>: Form-language traits for GMRES solvers.
template<class LinearSystem> struct Traits<Solver::HouseholderQR<LinearSystem>>: Form-language traits for HouseholderQR solvers.
template<class LinearSystem> struct Traits<Solver::IDRS<LinearSystem>>: Form-language traits for IDRS solvers.
template<class LinearSystem> struct Traits<Solver::IDRSTABL<LinearSystem>>: Form-language traits for IDRSTABL solvers.
template<> struct Traits<Solver::KSP>: Traits specialization for Solver::KSP (Rodin wrapper for PETSc KSP).
template<class LinearSystem> struct Traits<Solver::LDLT<LinearSystem>>: Form-language traits for LDLT solvers.
template<class LinearSystem> struct Traits<Solver::LeastSquaresCG<LinearSystem>>: Form-language traits for LeastSquaresCG solvers.
template<class LinearSystem> struct Traits<Solver::LinearSolverBase<LinearSystem>>: Form-language traits for linear solver bases.
template<class LinearSystem> struct Traits<Solver::MINRES<LinearSystem>>: Form-language traits for MINRES solvers.
template<class LinearSystem> struct Traits<Solver::PartialPivLU<LinearSystem>>: Form-language traits for PartialPivLU solvers.
template<class LinearSystem> struct Traits<Solver::SimplicialLDLT<LinearSystem>>: Form-language traits for SimplicialLDLT solvers.
template<class LinearSystem> struct Traits<Solver::SimplicialLLT<LinearSystem>>: Form-language traits for SimplicialLLT solvers.
template<class LinearSystem> struct Traits<Solver::SparseLU<LinearSystem>>: Form-language traits for SparseLU solvers.
template<class LinearSystem> struct Traits<Solver::SparseQR<LinearSystem>>: Form-language traits for SparseQR solvers.
template<class Solution, class TrialFES, class TestFES, class Operator> struct Traits<Variational::BilinearForm<Solution, TrialFES, TestFES, Operator>>: Traits for bilinear forms.
template<class Operator> struct Traits<Variational::BilinearFormBase<Operator>>: Traits for bilinear form bases.
template<class OperandDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Component<Variational::ShapeFunctionBase<OperandDerived, FES, Space>>>: Type traits for Component over a shape function: exposes the finite element space, the shape function space, the operand type, the scalar type and the range type.
template<class NestedDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Conjugate<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>>: Type traits for Conjugate over a shape function: exposes the finite element space and the shape function space.
template<size_t K, class Scalar, class Mesh, class Data> struct Traits<Variational::Derivative<Variational::GridFunction<Variational::H1<K, Scalar, Mesh>, Data>>>: Type traits for Derivative over a grid function: exposes the finite element space, the operand type and the range type.
template<class Range, class Data, class Mesh> struct Traits<Variational::Derivative<Variational::GridFunction<Variational::P1<Range, Mesh>, Data>>>: Type traits for Derivative over a grid function: exposes the finite element space, the operand type and the range type.
template<class NestedDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Derivative<Variational::ShapeFunction<NestedDerived, FES, Space>>>: Type traits for Derivative over a shape function: exposes the shape function space, the finite element space, the scalar type and the operand type.
template<class NestedDerived, class Range, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Derivative<Variational::ShapeFunction<NestedDerived, Variational::P1<Range, Mesh>, Space>>>: Type traits for Derivative over a shape function: exposes the finite element space, the shape function space, the operand type and the range type.
template<size_t K, class Scalar, class Data, class Mesh> struct Traits<Variational::Div<Variational::GridFunction<Variational::H1<K, Math::SpatialVector<Scalar>, Mesh>, Data>>>: Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
template<class Scalar, class Data, class Mesh> struct Traits<Variational::Div<Variational::GridFunction<Variational::P0g<Math::SpatialVector<Scalar>, Mesh>, Data>>>: Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
template<class Scalar, class Data, class Mesh> struct Traits<Variational::Div<Variational::GridFunction<Variational::P1<Math::SpatialVector<Scalar>, Mesh>, Data>>>: Type traits for Div over a grid function: exposes the finite element space, the scalar type and the operand type.
template<size_t K, class NestedDerived, class Scalar, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::H1<K, Math::SpatialVector<Scalar>, Mesh>, Space>>>: Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
template<class NestedDerived, class Scalar, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::P0g<Math::SpatialVector<Scalar>, Mesh>, Space>>>: Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
template<class NestedDerived, class Scalar, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Div<Variational::ShapeFunction<NestedDerived, Variational::P1<Math::SpatialVector<Scalar>, Mesh>, Space>>>: Type traits for Div over a shape function: exposes the finite element space, the shape function space, the scalar type and the operand type.
template<class LHSDerived, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Division<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::FunctionBase<RHSDerived>>>: Type traits for Division over a shape function: exposes the finite element space, the shape function space, the left-hand side operand, the right-hand side operand and the range type.
template<class LHSDerived, class RHSDerived> struct Traits<Variational::Dot<Variational::FunctionBase<LHSDerived>, Variational::FunctionBase<RHSDerived>>>: Type traits for Dot over a function expression: exposes the left-hand side operand, the right-hand side operand, the scalar type and the range type.
template<class LHSDerived, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Dot<Variational::FunctionBase<LHSDerived>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>>: Type traits for Dot over a function expression: exposes the finite element space, the shape function space, the left-hand side operand, the right-hand side operand, the scalar type and the range type.
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES> struct Traits<Variational::Dot<Variational::ShapeFunctionBase<LHSDerived, TrialFES, Variational::TrialSpace>, Variational::ShapeFunctionBase<RHSDerived, TestFES, Variational::TestSpace>>>: Type traits for Dot over a shape function: exposes the left-hand side operand, the right-hand side operand, the scalar type and the range type.
template<class Derived, class FES, class VectorField, class Step, class BoundaryPolicy> struct Traits<Variational::Flow<Variational::ShapeFunctionBase<Derived, FES, Variational::TestSpace>, VectorField, Step, BoundaryPolicy>>: Type traits for Flow over a shape function: exposes the finite element space, the shape function space and the operand type.
template<class Derived> struct Traits<Variational::FunctionBase<Derived>>: Form-language traits for variational functions.
template<class FES, class Data> struct Traits<Variational::Grad<Variational::GridFunction<FES, Data>>>: Type traits for Grad over a grid function: exposes the finite element space, the operand type and the range type.
template<class Range, class Data, class Mesh> struct Traits<Variational::Grad<Variational::GridFunction<Variational::P0<Range, Mesh>, Data>>>: Type traits for Grad over a grid function: exposes the finite element space and the operand type.
template<class NestedDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Grad<Variational::ShapeFunction<NestedDerived, FES, Space>>>: Type traits for Grad over a shape function: exposes the finite element space, the shape function space, the operand type and the range type.
template<class NestedDerived, class Range, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Grad<Variational::ShapeFunction<NestedDerived, Variational::P0<Range, Mesh>, Space>>>: Type traits for Grad over a shape function: exposes the finite element space, the shape function space and the operand type.
template<class FES, class Data> struct Traits<Variational::GridFunction<FES, Data>>: Traits for GridFunction: exposes the space and data types.
template<class Derived, class FES, class Data> struct Traits<Variational::GridFunctionBase<Derived, FES, Data>>: Traits for GridFunctionBase: exposes the space and data types.
template<size_t K, class Scalar, class Mesh> struct Traits<Variational::H1<K, Math::SpatialVector<Scalar>, Mesh>>: Type traits for H1: exposes the mesh type, the scalar type, the range type and the finite element type.
template<size_t K, class Scalar, class Mesh> struct Traits<Variational::H1<K, Scalar, Mesh>>: Type traits for H1: exposes the mesh type, the scalar type, the range type and the finite element type.
template<size_t K, class Range> struct Traits<Variational::H1Element<K, Range>>: Type traits for H1Element: exposes the scalar type and the range type of the element.
template<size_t K, class Range, class Data, class Mesh> struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::H1<K, Range, Mesh>, Data>>>: Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
template<class Range, class Data, class Mesh> struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::P0g<Range, Mesh>, Data>>>: Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
template<class Range, class Data, class Mesh> struct Traits<Variational::Jacobian<Variational::GridFunction<Variational::P1<Range, Mesh>, Data>>>: Type traits for Jacobian over a grid function: exposes the finite element space and the operand type.
template<size_t K, class NestedDerived, class Range, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::H1<K, Range, Mesh>, Space>>>: Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
template<class NestedDerived, class Range, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::P0g<Range, Mesh>, Space>>>: Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
template<class NestedDerived, class Range, class Mesh, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Jacobian<Variational::ShapeFunction<NestedDerived, Variational::P1<Range, Mesh>, Space>>>: Type traits for Jacobian over a shape function: exposes the finite element space, the shape function space and the operand type.
template<class FES, class Vector> struct Traits<Variational::LinearForm<FES, Vector>>: Type traits for LinearForm: exposes the finite element space and the vector type.
template<class Vector> struct Traits<Variational::LinearFormBase<Vector>>: Type traits for LinearFormBase: exposes the vector type.
template<class Scalar, class Derived> struct Traits<Variational::MatrixFunctionBase<Scalar, Derived>>: Type traits for MatrixFunctionBase: exposes the scalar type and the derived type.
template<class LHSDerived, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Mult<Variational::FunctionBase<LHSDerived>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>>: Type traits for Mult over a function expression: exposes the finite element space, the shape function space, the scalar type, the left-hand side operand, the right-hand side operand and the range type.
template<class LHSDerived, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Mult<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::FunctionBase<RHSDerived>>>: Type traits for Mult over a shape function: exposes the finite element space and the shape function space.
template<class Number, class Mesh> struct Traits<Variational::P0<Math::Vector<Number>, Mesh>>: Type traits for P0: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
template<class Number, class Mesh> struct Traits<Variational::P0<Number, Mesh>>: Type traits for P0: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
template<class Range> struct Traits<Variational::P0Element<Range>>: Type traits for P0Element: exposes the scalar type and the range type of the element.
template<class Number, class Mesh> struct Traits<Variational::P0g<Math::SpatialVector<Number>, Mesh>>: Type traits for P0g: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
template<class Number, class Mesh> struct Traits<Variational::P0g<Number, Mesh>>: Type traits for P0g: exposes the mesh type, the scalar type, the range type, the execution context and the finite element type.
template<class Range> struct Traits<Variational::P0gElement<Range>>: Type traits for P0gElement: exposes the scalar type and the range type.
template<class Scalar, class Mesh> struct Traits<Variational::P1<Math::SpatialVector<Scalar>, Mesh>>: Type traits for P1: exposes the mesh type, the scalar type, the range type and the finite element type.
template<class Scalar, class Mesh> struct Traits<Variational::P1<Scalar, Mesh>>: Type traits for P1: exposes the mesh type, the scalar type, the range type and the finite element type.
template<class Range> struct Traits<Variational::P1Element<Range>>: Type traits for P1Element: exposes the scalar type and the range type of the element.
template<class LHS, class RHSDerived> struct Traits<Variational::Potential<LHS, Variational::FunctionBase<RHSDerived>>>: Traits for Potential operator.
template<class LHS, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Potential<LHS, Variational::ShapeFunctionBase<Variational::ShapeFunction<RHSDerived, FES, Space>>>>: Traits for Potential.
template<class LinearSystem, class TrialFunction, class TestFunction> struct Traits<Variational::Problem<TrialFunction, TestFunction, LinearSystem>>: Form-language traits for a two-field variational problem.
template<class LinearSystem> struct Traits<Variational::ProblemBase<LinearSystem>>: Form-language traits for a problem base.
template<class Derived> struct Traits<Variational::RealFunctionBase<Derived>>: Traits for the CRTP base of real-valued functions.
template<class Scalar, class Derived> struct Traits<Variational::ScalarFunctionBase<Scalar, Derived>>: Type traits for ScalarFunctionBase: exposes the scalar type and the derived type.
template<class Derived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::ShapeFunction<Derived, FES, Space>>: Type traits for ShapeFunction: exposes the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
template<class Derived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::ShapeFunctionBase<Derived, FES, Space>>: Type traits for ShapeFunctionBase: exposes the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
template<class LHSDerived, class RHSDerived> struct Traits<Variational::Sum<Variational::FunctionBase<LHSDerived>, Variational::FunctionBase<RHSDerived>>>: Type traits for Sum over a function expression: exposes the left-hand side operand and the right-hand side operand.
template<class LHSNumber, class RHSNumber> struct Traits<Variational::Sum<Variational::LinearFormIntegratorBase<LHSNumber>, Variational::LinearFormIntegratorBase<RHSNumber>>>: Type traits for Sum over linear form integrators: exposes the left-hand side operand, the right-hand side operand and the scalar type.
template<class LHSDerived, class RHSDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Sum<Variational::ShapeFunctionBase<LHSDerived, FES, Space>, Variational::ShapeFunctionBase<RHSDerived, FES, Space>>>: Type traits for Sum over a shape function: exposes the finite element space, the left-hand side operand, the right-hand side operand and the shape function space.
template<class FES> struct Traits<Variational::TestFunction<FES>>: Type traits for TestFunction: exposes the finite element space and the shape function space.
template<class NestedDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::Trace<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>>: Type traits for Trace over a shape function: exposes the finite element space and the shape function space.
template<class Solution, class FES> struct Traits<Variational::TrialFunction<Solution, FES>>: Type traits for TrialFunction: exposes the finite element space, the shape function space and the solution type.
template<class NestedDerived, class FES, Variational::ShapeFunctionSpaceType Space> struct Traits<Variational::UnaryMinus<Variational::ShapeFunctionBase<NestedDerived, FES, Space>>>: Type traits for UnaryMinus over a shape function: exposes the finite element space and the shape function space.
template<class Scalar, class Derived> struct Traits<Variational::VectorFunctionBase<Scalar, Derived>>: Traits for vector-valued function bases.
template<> struct Traits<::Mat>: Traits specialization for PETSc matrices.
template<> struct Traits<::Vec>: Traits specialization for PETSc vectors.
template<class Operand> struct UnaryMinus: Type trait for deducing the result type of unary negation.

Enums

enum class RangeKind { Boolean, Integer, Real, Complex, Vector, Matrix, Unknown }: Type trait for deducing the result type of addition.

Variables

template<class T> auto RangeKindOfV constexpr: Convenience variable template for RangeKindOf<T>::Value.

Enum documentation

enum class Rodin::FormLanguage::RangeKind
#include <Rodin/Math/Traits.h>

Type trait for deducing the result type of addition.

Determines the type of at compile time.

Categorization of a value's range (scalar, vector or matrix kind).

Variable documentation

#include <Rodin/Math/Traits.h>

template<class T>
auto Rodin::FormLanguage::RangeKindOfV constexpr

Convenience variable template for RangeKindOf<T>::Value.