Rodin::FormLanguage module

Typed expressions for constructing variational forms.

An expression's C++ type records its operands and algebraic role. Function expressions represent known fields; shape-function expressions carry a trial or test slot; bilinear integrators pair those slots. Traits propagate scalar type, range and finite element space through composition.

auto stiffness = Integral(Grad(u), Grad(v));
auto load = Integral(f, v);
Problem problem(u, v);
problem = stiffness - load + DirichletBC(u, Zero());

Identity, copying and ownership

Base supplies identity and polymorphic copying. Expression nodes generally own copies of their child expressions, created with copy(). List stores polymorphic elements with value semantics through owned pointers. Each owned child is released with its owning expression.

Copying an expression does not necessarily copy its underlying mesh or solution coefficients. A grid-function expression can still refer to its finite element space and field storage. Keep those objects alive while the assembled forms use them; rebuilding a mesh or space requires reviewing dependent expressions and systems.

Evaluation and assembly

Traits describes the associated types of each node family. CRTP dispatch evaluates known-field expressions at geometric points; assembly supplies basis functions and quadrature to realize linear and bilinear forms. Constructing a form records that composition. A solver assembles and evaluates it according to the selected backend.

Evaluation and assembly may use mutable working state. Follow the thread-safety guide when sharing expressions across workers.

Classes

class Base
Base class for all objects in Rodin's FormLanguage system.
template<typename>
struct Debug
Template for debugging form language types.
template<class T>
class List
Container for polymorphic form language objects.
template<class ... Args>
struct Traits
Type traits for form language objects.
See specializations
SpecializationDescription
Adaptation::SWIFT::LinearSolver<…>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Adaptation::SWIFT::LinearSolver< LinearSystem >>;
Native solver traits for the SWIFT linear adapter.
Geometry::Mesh<Context>
Full specialization
template <
  class Context>
struct Traits<
  Geometry::Mesh< Context >>;
Traits specialization for Mesh types.
Rodin::Geometry::PointCloud
Full specialization
template <>
struct Traits<
  Rodin::Geometry::PointCloud>;
Type traits for a Geometry::PointCloud, exposing the scalar type.
Math::LinearSystem<Operator, Vector>
Full specialization
template <
  class Operator,
  class Vector>
struct Traits<
  Math::LinearSystem< Operator, Vector >>;
Type traits for a Math::LinearSystem, exposing the operator, vector, and scalar types.
Eigen::Matrix<Number, …>
Full specialization
template <
  class Number,
  int Rows,
  int Cols,
  int Options,
  int MaxRows,
  int MaxCols>
struct Traits<
  Eigen::Matrix< Number, Rows, Cols, Options, MaxRows, MaxCols >>;
Scalar type of a native Eigen dense matrix, including fixed and bounded types.
Math::Matrix<Number>
Full specialization
template <
  class Number>
struct Traits<
  Math::Matrix< Number >>;
Type traits for a dense Math::Matrix, exposing the scalar type.
Math::FixedSizeMatrix<Number, …>
Full specialization
template <
  class Number,
  size_t Rows,
  size_t Cols>
struct Traits<
  Math::FixedSizeMatrix< Number, Rows, Cols >>;
Scalar type of a fixed-size Rodin dense matrix.
Math::SparseMatrix<Number>
Full specialization
template <
  class Number>
struct Traits<
  Math::SparseMatrix< Number >>;
Type traits for a Math::SparseMatrix, exposing the scalar type.
Math::SpatialMatrix<Number>
Full specialization
template <
  class Number>
struct Traits<
  Math::SpatialMatrix< Number >>;
Type traits for a Math::SpatialMatrix, exposing the scalar type.
Math::SpatialTensor<Scalar, Rank>
Full specialization
template <
  class Scalar,
  size_t Rank>
struct Traits<
  Math::SpatialTensor< Scalar, Rank >>;
Type traits for the matrix or tensor expression specialization.
Math::SpatialVector<Number>
Full specialization
template <
  class Number>
struct Traits<
  Math::SpatialVector< Number >>;
Type traits for a Math::SpatialVector, exposing the scalar type.
Boolean
Full specialization
template <>
struct Traits<
  Boolean>;
Traits specialization for Boolean type.
Integer
Full specialization
template <>
struct Traits<
  Integer>;
Traits specialization for Integer type.
Real
Full specialization
template <>
struct Traits<
  Real>;
Traits specialization for Real type.
Complex
Full specialization
template <>
struct Traits<
  Complex>;
Traits specialization for Complex type.
Eigen::Matrix<Number, …>
Full specialization
template <
  class Number,
  int Rows,
  int Options,
  int MaxRows>
struct Traits<
  Eigen::Matrix< Number, Rows, 1, Options, MaxRows, 1 >>;
Scalar type of an Eigen column vector, including bounded vectors.
Math::Vector<Number>
Full specialization
template <
  class Number>
struct Traits<
  Math::Vector< Number >>;
Type traits for a dynamic Math::Vector, exposing the scalar type.
Math::FixedSizeVector<Number, S>
Full specialization
template <
  class Number,
  size_t S>
struct Traits<
  Math::FixedSizeVector< Number, S >>;
Type traits for a Math::FixedSizeVector, exposing the scalar type and the compile-time size.
::Mat
Full specialization
template <>
struct Traits<
  ::Mat>;
Traits specialization for PETSc matrices.
::Vec
Full specialization
template <>
struct Traits<
  ::Vec>;
Traits specialization for PETSc vectors.
Solver::KSP
Full specialization
template <>
struct Traits<
  Solver::KSP>;
Traits specialization for Solver::KSP (Rodin wrapper for PETSc KSP).
PETSc::Variational::GridFunction<FES>
Full specialization
template <
  class FES>
struct Traits<
  PETSc::Variational::GridFunction< FES >>;
Form-language traits specialization for PETSc grid functions.
PETSc::Variational::TestFunction<FES>
Full specialization
template <
  class FES>
struct Traits<
  PETSc::Variational::TestFunction< FES >>;
Form-language traits specialization for PETSc test functions.
PETSc::Variational::TrialFunction<Solution, …>
Full specialization
template <
  class Solution,
  class FES>
struct Traits<
  PETSc::Variational::TrialFunction< Solution, FES >>;
Form-language traits specialization for PETSc trial functions.
Variational::LinearElasticityForm<Solution, …>
Full specialization
template <
  class Solution,
  class FES,
  class Operator,
  class LambdaDerived,
  class MuDerived>
struct Traits<
  Variational::LinearElasticityForm< Solution, FES, Operator, LambdaDerived, MuDerived >>;
Traits of a Variational::LinearElasticityForm.
Solver::BiCGSTAB<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::BiCGSTAB< LinearSystem >>;
Form-language traits for BiCGSTAB solvers.
Solver::CG<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::CG< LinearSystem >>;
Form-language traits for CG solvers.
Solver::DGMRES<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::DGMRES< LinearSystem >>;
Form-language traits for DGMRES solvers.
Solver::GMRES<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::GMRES< LinearSystem >>;
Form-language traits for GMRES solvers.
Solver::HouseholderQR<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::HouseholderQR< LinearSystem >>;
Form-language traits for HouseholderQR solvers.
Solver::IDRS<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::IDRS< LinearSystem >>;
Form-language traits for IDRS solvers.
Solver::IDRSTABL<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::IDRSTABL< LinearSystem >>;
Form-language traits for IDRSTABL solvers.
Solver::LDLT<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::LDLT< LinearSystem >>;
Form-language traits for LDLT solvers.
Solver::LeastSquaresCG<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::LeastSquaresCG< LinearSystem >>;
Form-language traits for LeastSquaresCG solvers.
Solver::LinearSolverBase<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::LinearSolverBase< LinearSystem >>;
Form-language traits for linear solver bases.
Solver::MINRES<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::MINRES< LinearSystem >>;
Form-language traits for MINRES solvers.
Solver::PartialPivLU<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::PartialPivLU< LinearSystem >>;
Form-language traits for PartialPivLU solvers.
Solver::SimplicialLDLT<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::SimplicialLDLT< LinearSystem >>;
Form-language traits for SimplicialLDLT solvers.
Solver::SimplicialLLT<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::SimplicialLLT< LinearSystem >>;
Form-language traits for SimplicialLLT solvers.
Solver::SparseLU<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::SparseLU< LinearSystem >>;
Form-language traits for SparseLU solvers.
Solver::SparseQR<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Solver::SparseQR< LinearSystem >>;
Form-language traits for SparseQR solvers.
Variational::BilinearFormBase<Operator>
Full specialization
template <
  class Operator>
struct Traits<
  Variational::BilinearFormBase< Operator >>;
Traits for bilinear form bases.
Variational::BilinearForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator>
struct Traits<
  Variational::BilinearForm< Solution, TrialFES, TestFES, Operator >>;
Traits for bilinear forms.
Variational::Component<…>
Full specialization
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, exposing the finite element space, the shape function space, the operand type, the scalar type and the range type.
Variational::Conjugate<…>
Full specialization
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, exposing the finite element space and the shape function space.
Variational::Derivative<…>
Full specialization
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, exposing the shape function space, the finite element space, the scalar type and the operand type.
Variational::Derivative<…>
Full specialization
template <
  class FES,
  class Data>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Derivative< Variational::GridFunction< FES, Data > >>;
Type traits for the matrix or tensor expression specialization.
Variational::Derivative<…>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Derivative< Variational::ShapeFunction< Derived, FES, Space > >>;
Type traits for the matrix or tensor expression specialization.
Variational::DiffusionForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class CoefficientDerived>
struct Traits<
  Variational::DiffusionForm< Solution, TrialFES, TestFES, Operator, CoefficientDerived >>;
Traits of a Variational::DiffusionForm.
Variational::Div<…>
Full specialization
template <
  class FES,
  class Data>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Div< Variational::GridFunction< FES, Data > >>;
Type traits for the matrix or tensor expression specialization.
Variational::Div<…>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Div< Variational::ShapeFunction< Derived, FES, Space > >>;
Type traits for the matrix or tensor expression specialization.
Variational::Division<…>
Full specialization
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, exposing the finite element space, the shape function space, the left-hand side operand, the right-hand side operand and the range type.
Variational::Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
struct Traits<
  Variational::Dot< Variational::FunctionBase< LHSDerived >, Variational::FunctionBase< RHSDerived > >>;
Type traits for Dot over a function expression, exposing the left-hand side operand, the right-hand side operand, the scalar type and the range type.
Variational::Dot<…>
Full specialization
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, exposing 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.
Variational::Dot<…>
Full specialization
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, exposing the left-hand side operand, the right-hand side operand, the scalar type and the range type.
Variational::Flow<…>
Full specialization
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, exposing the finite element space, the shape function space and the operand type.
Variational::FunctionBase<Derived>
Full specialization
template <
  class Derived>
struct Traits<
  Variational::FunctionBase< Derived >>;
Form-language traits for variational functions.
Variational::Grad<…>
Full specialization
template <
  class FES,
  class Data>
struct Traits<
  Variational::Grad< Variational::GridFunction< FES, Data > >>;
Type traits for Grad over a grid function, exposing the finite element space, the operand type and the range type.
Variational::Grad<…>
Full specialization
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, exposing the finite element space, the shape function space, the operand type and the range type.
Variational::GridFunctionBase<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  class Data>
struct Traits<
  Variational::GridFunctionBase< Derived, FES, Data >>;
Traits for GridFunctionBase, exposing the space and data types.
Variational::GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
struct Traits<
  Variational::GridFunction< FES, Data >>;
Traits for GridFunction, exposing the space and data types.
Variational::Derivative<…>
Full specialization
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, exposing the finite element space, the operand type and the range type.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the scalar type and the operand type.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the shape function space, the scalar type and the operand type.
Variational::Grad<…>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Data>
struct Traits<
  Variational::Grad< Variational::GridFunction< Variational::H1< K, Math::SpatialMatrix< Scalar >, Mesh >, Data > >>;
Rank-three physical gradient range for the matrix H1 solution.
Variational::Grad<…>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Derived,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::Grad< Variational::ShapeFunction< Derived, Variational::H1< K, Math::SpatialMatrix< Scalar >, Mesh >, Space > >>;
Rank-three physical gradient range for matrix H1 shape functions.
Variational::H1<K, Scalar, Mesh>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh>
struct Traits<
  Variational::H1< K, Scalar, Mesh >>;
Type traits for H1, exposing the mesh type, the scalar type, the range type and the finite element type.
Variational::H1<K, …>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh>
struct Traits<
  Variational::H1< K, Math::SpatialVector< Scalar >, Mesh >>;
Type traits for H1, exposing the mesh type, the scalar type, the range type and the finite element type.
Variational::H1<K, …>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh>
struct Traits<
  Variational::H1< K, Math::SpatialMatrix< Scalar >, Mesh >>;
Type traits for the matrix or tensor expression specialization.
Variational::H1Element<K, Range>
Full specialization
template <
  size_t K,
  class Range>
struct Traits<
  Variational::H1Element< K, Range >>;
Type traits for H1Element, exposing the scalar type and the range type of the element.
Variational::Jacobian<…>
Full specialization
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, exposing the finite element space and the operand type.
Variational::Jacobian<…>
Full specialization
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, exposing the finite element space, the shape function space and the operand type.
Variational::HelmholtzForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class DiffusionDerived,
  class MassDerived>
struct Traits<
  Variational::HelmholtzForm< Solution, TrialFES, TestFES, Operator, DiffusionDerived, MassDerived >>;
Traits of a Variational::HelmholtzForm.
Variational::Jacobian<…>
Full specialization
template <
  class FES,
  class Data>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Jacobian< Variational::GridFunction< FES, Data > >>;
Type traits for the matrix or tensor expression specialization.
Variational::Jacobian<…>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
requires IsMatrixRange<typename Traits<FES>::RangeType>::Value
struct Traits<
  Variational::Jacobian< Variational::ShapeFunction< Derived, FES, Space > >>;
Type traits for the matrix or tensor expression specialization.
Variational::LinearFormBase<Vector>
Full specialization
template <
  class Vector>
struct Traits<
  Variational::LinearFormBase< Vector >>;
Type traits for LinearFormBase, exposing the vector type.
Variational::LinearForm<FES, Vector>
Full specialization
template <
  class FES,
  class Vector>
struct Traits<
  Variational::LinearForm< FES, Vector >>;
Type traits for LinearForm, exposing the finite element space and the vector type.
Variational::MassForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class CoefficientDerived>
struct Traits<
  Variational::MassForm< Solution, TrialFES, TestFES, Operator, CoefficientDerived >>;
Traits of a Variational::MassForm.
Variational::MatrixFunctionBase<Scalar, …>
Full specialization
template <
  class Scalar,
  class Derived>
struct Traits<
  Variational::MatrixFunctionBase< Scalar, Derived >>;
Type traits for MatrixFunctionBase, exposing the scalar type and the derived type.
Variational::Mult<…>
Full specialization
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, exposing 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.
Variational::Mult<…>
Full specialization
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, exposing the finite element space and the shape function space.
Variational::Grad<…>
Full specialization
template <
  class Range,
  class Data,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
struct Traits<
  Variational::Grad< Variational::GridFunction< Variational::P0< Range, Mesh >, Data > >>;
Type traits for Grad over a grid function, exposing the finite element space and the operand type.
Variational::Grad<…>
Full specialization
template <
  class NestedDerived,
  class Range,
  class Mesh,
  Variational::ShapeFunctionSpaceType Space>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
struct Traits<
  Variational::Grad< Variational::ShapeFunction< NestedDerived, Variational::P0< Range, Mesh >, Space > >>;
Type traits for Grad over a shape function, exposing the finite element space, the shape function space and the operand type.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
struct Traits<
  Variational::Grad< Variational::GridFunction< Variational::P0< Math::SpatialMatrix< Scalar >, Mesh >, Data > >>;
Rank-three physical gradient range for the matrix P0 solution.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::Grad< Variational::ShapeFunction< Derived, Variational::P0< Math::SpatialMatrix< Scalar >, Mesh >, Space > >>;
Rank-three physical gradient range for matrix P0 shape functions.
Variational::P0<Number, Mesh>
Full specialization
template <
  class Number,
  class Mesh>
struct Traits<
  Variational::P0< Number, Mesh >>;
Type traits for P0, exposing the mesh type, the scalar type, the range type, the execution context and the finite element type.
Variational::P0<…>
Full specialization
template <
  class Number,
  class Mesh>
struct Traits<
  Variational::P0< Math::SpatialVector< Number >, Mesh >>;
Type traits for P0, exposing the mesh type, the scalar type, the range type, the execution context and the finite element type.
Variational::P0<…>
Full specialization
template <
  class Scalar,
  class Mesh>
struct Traits<
  Variational::P0< Math::SpatialMatrix< Scalar >, Mesh >>;
Type traits for the matrix or tensor expression specialization.
Variational::P0Element<Range>
Full specialization
template <
  class Range>
struct Traits<
  Variational::P0Element< Range >>;
Type traits for P0Element, exposing the scalar type and the range type of the element.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the scalar type and the operand type.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the shape function space, the scalar type and the operand type.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
struct Traits<
  Variational::Grad< Variational::GridFunction< Variational::P0g< Math::SpatialMatrix< Scalar >, Mesh >, Data > >>;
Rank-three physical gradient range for the matrix P0g solution.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::Grad< Variational::ShapeFunction< Derived, Variational::P0g< Math::SpatialMatrix< Scalar >, Mesh >, Space > >>;
Rank-three physical gradient range for matrix P0g shape functions.
Variational::Jacobian<…>
Full specialization
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, exposing the finite element space and the operand type.
Variational::Jacobian<…>
Full specialization
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, exposing the finite element space, the shape function space and the operand type.
Variational::P0g<Number, Mesh>
Full specialization
template <
  class Number,
  class Mesh>
struct Traits<
  Variational::P0g< Number, Mesh >>;
Type traits for P0g, exposing the mesh type, the scalar type, the range type, the execution context and the finite element type.
Variational::P0g<…>
Full specialization
template <
  class Number,
  class Mesh>
struct Traits<
  Variational::P0g< Math::SpatialVector< Number >, Mesh >>;
Type traits for P0g, exposing the mesh type, the scalar type, the range type, the execution context and the finite element type.
Variational::P0g<…>
Full specialization
template <
  class Scalar,
  class Mesh>
struct Traits<
  Variational::P0g< Math::SpatialMatrix< Scalar >, Mesh >>;
Type traits for the matrix or tensor expression specialization.
Variational::P0gElement<Range>
Full specialization
template <
  class Range>
struct Traits<
  Variational::P0gElement< Range >>;
Type traits for P0gElement, exposing the scalar type and the range type.
Variational::Derivative<…>
Full specialization
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, exposing the finite element space, the operand type and the range type.
Variational::Derivative<…>
Full specialization
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, exposing the finite element space, the shape function space, the operand type and the range type.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the scalar type and the operand type.
Variational::Div<…>
Full specialization
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, exposing the finite element space, the shape function space, the scalar type and the operand type.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
struct Traits<
  Variational::Grad< Variational::GridFunction< Variational::P1< Math::SpatialMatrix< Scalar >, Mesh >, Data > >>;
Rank-three physical gradient range for the matrix P1 solution.
Variational::Grad<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::Grad< Variational::ShapeFunction< Derived, Variational::P1< Math::SpatialMatrix< Scalar >, Mesh >, Space > >>;
Rank-three physical gradient range for matrix P1 shape functions.
Variational::Jacobian<…>
Full specialization
template <
  class Range,
  class Data,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
struct Traits<
  Variational::Jacobian< Variational::GridFunction< Variational::P1< Range, Mesh >, Data > >>;
Type traits for Jacobian over a grid function, exposing the finite element space and the operand type.
Variational::Jacobian<…>
Full specialization
template <
  class NestedDerived,
  class Range,
  class Mesh,
  Variational::ShapeFunctionSpaceType Space>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
struct Traits<
  Variational::Jacobian< Variational::ShapeFunction< NestedDerived, Variational::P1< Range, Mesh >, Space > >>;
Type traits for Jacobian over a shape function, exposing the finite element space, the shape function space and the operand type.
Variational::P1<Scalar, Mesh>
Full specialization
template <
  class Scalar,
  class Mesh>
struct Traits<
  Variational::P1< Scalar, Mesh >>;
Type traits for P1, exposing the mesh type, the scalar type, the range type and the finite element type.
Variational::P1<…>
Full specialization
template <
  class Scalar,
  class Mesh>
struct Traits<
  Variational::P1< Math::SpatialVector< Scalar >, Mesh >>;
Type traits for P1, exposing the mesh type, the scalar type, the range type and the finite element type.
Variational::P1<…>
Full specialization
template <
  class Scalar,
  class Mesh>
struct Traits<
  Variational::P1< Math::SpatialMatrix< Scalar >, Mesh >>;
Type traits for the matrix or tensor expression specialization.
Variational::P1Element<Range>
Full specialization
template <
  class Range>
struct Traits<
  Variational::P1Element< Range >>;
Type traits for P1Element, exposing the scalar type and the range type of the element.
Variational::Potential<LHS, …>
Full specialization
template <
  class LHS,
  class RHSDerived>
struct Traits<
  Variational::Potential< LHS, Variational::FunctionBase< RHSDerived > >>;
Traits for Potential operator.
Variational::Potential<LHS, …>
Full specialization
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.
Variational::ProblemBase<LinearSystem>
Full specialization
template <
  class LinearSystem>
struct Traits<
  Variational::ProblemBase< LinearSystem >>;
Form-language traits for a problem base.
Variational::Problem<TrialFunction, …>
Full specialization
template <
  class LinearSystem,
  class TrialFunction,
  class TestFunction>
struct Traits<
  Variational::Problem< TrialFunction, TestFunction, LinearSystem >>;
Form-language traits for a two-field variational problem.
Variational::RealFunctionBase<Derived>
Full specialization
template <
  class Derived>
struct Traits<
  Variational::RealFunctionBase< Derived >>;
Traits for the CRTP base of real-valued functions.
Variational::ScalarFunctionBase<Scalar, …>
Full specialization
template <
  class Scalar,
  class Derived>
struct Traits<
  Variational::ScalarFunctionBase< Scalar, Derived >>;
Type traits for ScalarFunctionBase, exposing the scalar type and the derived type.
Variational::ShapeFunctionBase<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::ShapeFunctionBase< Derived, FES, Space >>;
Type traits for ShapeFunctionBase, exposing the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
Variational::ShapeFunction<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct Traits<
  Variational::ShapeFunction< Derived, FES, Space >>;
Type traits for ShapeFunction, exposing the derived type, the finite element space, the shape function space, the result type, the range type and the scalar type.
Variational::Sum<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
struct Traits<
  Variational::Sum< Variational::FunctionBase< LHSDerived >, Variational::FunctionBase< RHSDerived > >>;
Type traits for Sum over a function expression, exposing the left-hand side operand and the right-hand side operand.
Variational::Sum<…>
Full specialization
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, exposing the finite element space, the left-hand side operand, the right-hand side operand and the shape function space.
Variational::Sum<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
struct Traits<
  Variational::Sum< Variational::LinearFormIntegratorBase< LHSNumber >, Variational::LinearFormIntegratorBase< RHSNumber > >>;
Type traits for Sum over linear form integrators, exposing the left-hand side operand, the right-hand side operand and the scalar type.
Variational::TestFunction<FES>
Full specialization
template <
  class FES>
struct Traits<
  Variational::TestFunction< FES >>;
Type traits for TestFunction, exposing the finite element space and the shape function space.
Variational::Trace<…>
Full specialization
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, exposing the finite element space and the shape function space.
Variational::TrialFunction<Solution, …>
Full specialization
template <
  class Solution,
  class FES>
struct Traits<
  Variational::TrialFunction< Solution, FES >>;
Type traits for TrialFunction, exposing the finite element space, the shape function space and the solution type.
Variational::UnaryMinus<…>
Full specialization
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, exposing the finite element space and the shape function space.
Variational::VectorFunctionBase<Scalar, …>
Full specialization
template <
  class Scalar,
  class Derived>
struct Traits<
  Variational::VectorFunctionBase< Scalar, Derived >>;
Traits for vector-valued function bases.
template<class T>
struct IsPlainObject
Type trait to identify Eigen plain object types.
See specializations
SpecializationDescription
Eigen::PlainObjectBase<Derived>
Full specialization
template <
  class Derived>
struct IsPlainObject<
  Eigen::PlainObjectBase< Derived >>;
Specialization for Eigen::PlainObjectBase types.
template<class T, class Enable = void>
struct IsSpecialized
Whether T is an optimized specialization rather than a generic handler.
See specializations
SpecializationDescription
T, std::void_t<decltype(T::Specialized)>
Full specialization
template <
  class T>
struct IsSpecialized<
  T,
  std::void_t< decltype(T::Specialized)>>;
Specialization for types declaring a Specialized member.
template<class T>
struct FunctionDerived
Derived type D of the Variational::FunctionBase<D> that T inherits from.
template<class T>
struct IsNamedForm
Indicates whether T is a named bilinear form.
See specializations
SpecializationDescription
Variational::LinearElasticityForm<Solution, …>
Full specialization
template <
  class Solution,
  class FES,
  class Operator,
  class LambdaDerived,
  class MuDerived>
struct IsNamedForm<
  Variational::LinearElasticityForm< Solution, FES, Operator, LambdaDerived, MuDerived >>;
Marks Variational::LinearElasticityForm as a named form.
Variational::DiffusionForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class CoefficientDerived>
struct IsNamedForm<
  Variational::DiffusionForm< Solution, TrialFES, TestFES, Operator, CoefficientDerived >>;
Marks Variational::DiffusionForm as a named form.
Variational::HelmholtzForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class DiffusionDerived,
  class MassDerived>
struct IsNamedForm<
  Variational::HelmholtzForm< Solution, TrialFES, TestFES, Operator, DiffusionDerived, MassDerived >>;
Marks Variational::HelmholtzForm as a named form.
Variational::MassForm<Solution, …>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Operator,
  class CoefficientDerived>
struct IsNamedForm<
  Variational::MassForm< Solution, TrialFES, TestFES, Operator, CoefficientDerived >>;
Marks Variational::MassForm as a named form.
template<class T>
struct IsEigenObject
Type trait to check if a type is an Eigen object.
template<class T, class = void>
struct ColsAtCompileTime
Compile-time column count of a type; -1 when unavailable.
See specializations
SpecializationDescription
T, std::void_t<…>
Full specialization
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<class T>
struct IsSpatialVector
Indicates whether T is a Math::SpatialVector.
See specializations
SpecializationDescription
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
struct IsSpatialVector<
  Math::SpatialVector< Scalar >>;
Type trait specialization for Math::SpatialVector.
template<class T>
struct IsSpatialMatrix
Indicates whether T is a Math::SpatialMatrix.
See specializations
SpecializationDescription
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
struct IsSpatialMatrix<
  Math::SpatialMatrix< Scalar >>;
Type trait specialization for Math::SpatialMatrix.
template<class T>
struct IsTensorRange
Indicates whether T has vector range (a spatial vector or a single-column Eigen object).
See specializations
SpecializationDescription
Math::SpatialTensor<Scalar, Rank>
Full specialization
template <
  class Scalar,
  size_t Rank>
struct IsTensorRange<
  Math::SpatialTensor< Scalar, Rank >>;
Matrix-range finite element or expression specialization.
template<class T>
struct IsVectorRange
Matrix-range finite element or expression specialization.
template<class T>
struct IsMatrixRange
Indicates whether T has matrix range (a spatial matrix or a multi-column Eigen object).
template<class T>
struct RangeKindOf
Deduces the RangeKind of a type T.
template<class LHS, class RHS>
struct Sum
Type trait for deducing the result type of addition.
template<class LHS, class RHS>
struct Minus
Type trait for deducing the result type of subtraction.
template<class Operand>
struct UnaryMinus
Type trait for deducing the result type of unary negation.
template<class LHS, class RHS>
struct Mult
Type trait for deducing the result type of multiplication.
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 Solution, class Scalar>
struct NamedFormOperatorType
Selects named-form operators from the trial solution type.
See specializations
SpecializationDescription
Solution, Scalar
Full specialization
template <
  class Solution,
  class Scalar>
requires std::is_same_v<typename Traits<Solution>::DataType, ::Vec>
struct NamedFormOperatorType<
  Solution,
  Scalar>;
Selects PETSc operators for PETSc trial coefficient storage.
template<class T>
struct IsInterfaceShapeFunction
Detects shape expressions whose basis spans two incident cells.
See specializations
SpecializationDescription
Variational::ShapeFunctionBase<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct IsInterfaceShapeFunction<
  Variational::ShapeFunctionBase< Derived, FES, Space >>;
Propagates two-cell support through a shape expression.
Variational::Average<…>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct IsInterfaceShapeFunction<
  Variational::Average< Variational::ShapeFunctionBase< Derived, FES, Space > >>;
Propagates two-cell support through a shape expression.
Variational::Jump<…>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct IsInterfaceShapeFunction<
  Variational::Jump< Variational::ShapeFunctionBase< Derived, FES, Space > >>;
Propagates two-cell support through a shape expression.
Variational::Conjugate<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Conjugate< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Transpose<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Transpose< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Trace<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Trace< Operand >>;
Propagates the operand's support through a unary expression.
Variational::UnaryMinus<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::UnaryMinus< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Grad<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Grad< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Div<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Div< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Jacobian<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Jacobian< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Derivative<Operand>
Full specialization
template <
  class Operand>
struct IsInterfaceShapeFunction<
  Variational::Derivative< Operand >>;
Propagates the operand's support through a unary expression.
Variational::Sum<LHS, RHS>
Full specialization
template <
  class LHS,
  class RHS>
struct IsInterfaceShapeFunction<
  Variational::Sum< LHS, RHS >>;
Detects two-cell support in either binary operand.
Variational::Mult<LHS, RHS>
Full specialization
template <
  class LHS,
  class RHS>
struct IsInterfaceShapeFunction<
  Variational::Mult< LHS, RHS >>;
Detects two-cell support in either binary operand.
Variational::Division<LHS, RHS>
Full specialization
template <
  class LHS,
  class RHS>
struct IsInterfaceShapeFunction<
  Variational::Division< LHS, RHS >>;
Detects two-cell support in either binary operand.
Variational::Dot<LHS, RHS>
Full specialization
template <
  class LHS,
  class RHS>
struct IsInterfaceShapeFunction<
  Variational::Dot< LHS, RHS >>;
Detects two-cell support in either binary operand.
Variational::Component<Operand, …>
Full specialization
template <
  class Operand,
  class... Indices>
struct IsInterfaceShapeFunction<
  Variational::Component< Operand, Indices... >>;
Propagates support through component selection.
template<class T>
struct ResultOf
Type trait to deduce the result type of an expression.
See specializations
SpecializationDescription
Variational::FunctionBase<Derived>
Full specialization
template <
  class Derived>
struct ResultOf<
  Variational::FunctionBase< Derived >>;
Specialization of ResultOf for FunctionBase.
Variational::ShapeFunctionBase<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct ResultOf<
  Variational::ShapeFunctionBase< Derived, FES, Space >>;
Specialization of ResultOf for ShapeFunctionBase.
template<class MatrixXpr>
struct RangeOf
Type trait to deduce the mathematical range type of an expression.
See specializations
SpecializationDescription
Boolean
Full specialization
template <>
struct RangeOf<
  Boolean>;
Range type for Boolean values.
Integer
Full specialization
template <>
struct RangeOf<
  Integer>;
Range type for Integer values.
Real
Full specialization
template <>
struct RangeOf<
  Real>;
Range type for Real values.
Complex
Full specialization
template <>
struct RangeOf<
  Complex>;
Range type for Complex values.
Eigen::Matrix<Scalar, …>
Full specialization
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.
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
struct RangeOf<
  Math::SpatialVector< Scalar >>;
Range type deduced for Math::SpatialVector.
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
struct RangeOf<
  Math::SpatialMatrix< Scalar >>;
Range type deduced for Math::SpatialMatrix.
Eigen::Matrix<Scalar, …>
Full specialization
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.
Math::SpatialTensor<Scalar, Rank>
Full specialization
template <
  class Scalar,
  size_t Rank>
struct RangeOf<
  Math::SpatialTensor< Scalar, Rank >>;
Range type for FunctionBase.
Variational::FunctionBase<Derived>
Full specialization
template <
  class Derived>
struct RangeOf<
  Variational::FunctionBase< Derived >>;
Type traits for the matrix or tensor expression specialization.
Variational::ShapeFunctionBase<Derived, …>
Full specialization
template <
  class Derived,
  class FES,
  Variational::ShapeFunctionSpaceType Space>
struct RangeOf<
  Variational::ShapeFunctionBase< Derived, FES, Space >>;
Range type for ShapeFunctionBase.

Enums

enum class RangeKind { Boolean, Integer, Real, Complex, Vector, Matrix, Tensor, 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

Defined in Rodin/Math/Traits.h

Type trait for deducing the result type of addition.

Determines the type of $ \text{LHS} + \text{RHS} $ at compile time.

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

Variable documentation

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

Defined in Rodin/Math/Traits.h

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