Rodin::Variational module

Finite element spaces, fields, and variational problems.

H1 and P1 define finite element spaces, while GridFunction evaluates and interpolates discrete fields. TrialFunction, TestFunction, and Problem express weak forms, boundary conditions, and the algebraic problems used to solve PDEs.

Finite Element Spaces

  • P0 — Piecewise constant (discontinuous) finite element space
  • P0g — Global constant space (1 DOF for scalar, vdim for vector)
  • P1 — Piecewise linear (continuous) finite element space
  • H1 — Higher-order $ H^1 $ -conforming finite element space (arbitrary polynomial order)

Functions

  • TrialFunction — Represents the unknown solution $ u $ in a variational formulation
  • TestFunction — Represents the weighting function $ v $
  • GridFunction — A concrete function storing DOF values in a finite element space

Variational Forms

The module supports building variational problems of the form:

\[ \text{Find} \quad u \in U \quad \text{ s.t. } \quad \forall v \in V \quad a(u, v) = b(v) \ , \]

which are translated into linear algebra problems $ \mathbf{A}\mathbf{x} = \mathbf{b} $ .

Key expression classes:

  • Integral(A, B) — Domain integrals (bilinear or linear forms)
  • BoundaryIntegral(A, B) — Boundary integrals
  • FaceIntegral(A, B) — Integrals over all faces (interior + boundary)
  • InterfaceIntegral(A, B) — Integrals over interior faces only

Differential operators:

  • Grad(u) — Gradient operator
  • Div(u) — Divergence operator
  • Jacobian(u) — Jacobian (gradient of vector field)
  • Transpose(A) — Matrix transpose

Algebraic operators:

  • Dot(A, B) — Inner product / Frobenius contraction
  • Trace(A) — Matrix trace
  • Frobenius(A) — Frobenius norm
  • Component(u, i) — Extract $ i $ -th component of vector function

DG operators:

  • Jump(u) — Jump across internal faces: $ [u] = u^+ - u^- $
  • Average(u) — Average across internal faces: $ \{u\} = (u^+ + u^-)/2 $

Boundary conditions:

  • DirichletBC(u, g) — Essential boundary conditions
  • PeriodicBC(u, dofMap) — Periodic boundary conditions

Convenience functions:

  • RealFunction — Scalar function from constant or lambda
  • VectorFunction — Vector function from initializer list
  • Zero — Zero scalar/vector function
  • Pow, Exp, Sqrt, Sin, Cos, Tan, Abs, Min, Max — Pointwise math operations

Special operators:

  • BoundaryNormal(mesh) — Outward unit normal on $ \partial\Omega $
  • FaceNormal(mesh) — Unit normal on mesh faces
  • IdentityMatrix(n) — $ n \times n $ identity matrix function
  • F::x, F::y, F::z — Coordinate projection functions
  • Re(u), Im(u), Conjugate(u) — Complex-valued function operators

Advanced operators:

  • Potential(K, u) — Integral convolution: $ \int K(\mathbf{x},\mathbf{y}) u(\mathbf{y}) \, d\mathbf{y} $
  • Flow(t, u, vel) — Flow composition $ u \circ \Phi_t $ (characteristic tracing for advection)
  • TraceOperator(u, attr) — Boundary trace $ u|_{\partial\Omega} $
  • LinearElasticityIntegral(u, v)(lambda, mu) — Hooke elasticity bilinear form

Problem

The Problem class assembles all forms and boundary conditions into a solvable linear system.

P1 Vh(mesh);
TrialFunction u(Vh);
TestFunction  v(Vh);

Problem poisson(u, v);
poisson = Integral(Grad(u), Grad(v))
        - Integral(f, v)
        + DirichletBC(u, Zero());

Solver::CG(poisson).solve();

Namespaces

namespace F
Contains built-in coordinate functions.

Classes

template<class T>
struct IsPETScTrialFunction
Primary template for IsPETScTrialFunction.
template<class T>
struct IsPETScTestFunction
Primary template for IsPETScTestFunction.
template<class... Ts>
struct AllPETScTrialOrTest
Primary template for AllPETScTrialOrTest.
template<class Solution, class FES, class LambdaDerived, class MuDerived>
class LinearElasticityIntegrator
Bilinear form integrator for linear elasticity.
See specializations
SpecializationDescription
Solution, P1<Range, Mesh>, LambdaDerived, MuDerived
Full specialization
template <
  class Solution,
  class LambdaDerived,
  class MuDerived,
  class Range,
  class Mesh>
class LinearElasticityIntegrator<
  Solution,
  P1< Range, Mesh >,
  LambdaDerived,
  MuDerived> final;
P1 linear elasticity bilinear form integrator.
template<class Solution, class FES>
class LinearElasticityIntegral
Helper class to construct linear elasticity integrators.
template<class Solution, class FES, class Operator, class LambdaDerived, class MuDerived>
class LinearElasticityForm
Discrete isotropic linear elasticity form.
template<class Operator>
class BilinearFormBase
Base class for bilinear form representations.
template<class Number, class Derived>
class BilinearFormIntegratorBase
Abstract base class for bilinear form integrators.
template<class Number>
class LocalBilinearFormIntegratorBase
Base class for bilinear form integrators whose trial and test functions live on the same polytope.
template<class Number>
class GlobalBilinearFormIntegratorBase
Base class for bilinear form integrators coupling a trial and a test polytope across the mesh.
template<class Derived>
class BooleanFunctionBase
Base class for boolean-valued functions.
class BoundaryNormal
Outward unit normal vector on domain boundaries.
template<class Derived>
class ComplexFunctionBase
Base class for complex-valued scalar functions.
template<class ... Parameters>
class DenseProblem
See specializations
SpecializationDescription
LinearSystem, U, V
Full specialization
template <
  class LinearSystem,
  class U,
  class V>
class DenseProblem<
  LinearSystem,
  U,
  V>;
General class to assemble linear systems with Math::Matrix and Math::Vector types in a serial context.
template<class Operand, class Derived>
class DerivativeBase
Base class for directional derivative operators.
See specializations
SpecializationDescription
GridFunction<FES, Data>, Derived
Full specialization
template <
  class FES,
  class Data,
  class Derived>
class DerivativeBase<
  GridFunction< FES, Data >,
  Derived>;
CRTP base for the partial derivative of a grid function.
template<class Solution, class TrialFES, class TestFES, class Operator, class CoefficientDerived>
class DiffusionForm
Discrete diffusion form $ a(u,v) = \int_\Omega a\, \nabla u \cdot \nabla v\,dx $ .
template<class Scalar>
class DirichletBCBase
Abstract base class for a Dirichlet boundary condition.
template<class Operand, class Derived>
class DivBase
Base class for divergence operator implementations.
See specializations
SpecializationDescription
GridFunction<FES, Data>, Derived
Full specialization
template <
  class FES,
  class Data,
  class Derived>
class DivBase<
  GridFunction< FES, Data >,
  Derived>;
Divergence of a P1 GridFunction.
template<bool Enabled = true>
class DOFMapping
Local numbering of the union of two finite-element DOF sets.
See specializations
SpecializationDescription
true
Full specialization
template <>
class DOFMapping<
  true>;
Union numbering and side-local indices for distinct supports.
class TestFunctionMismatchException
Raised when an expression is combined with a foreign test function.
class TrialFunctionMismatchException
Raised when an expression is combined with a foreign trial function.
template<class T, class FuncName>
class UndeterminedTraceDomainException
Raised when the trace of a function is taken without a determined domain.
class FaceNormal
Unit normal vector on codimension-one mesh entities.
template<class Derived>
class FiniteElementBase
Base class for finite elements.
class FiniteElementSpaceBase
Base class for finite element spaces.
template<class Mesh, class Derived>
class FiniteElementSpace
Represernts a finite element space.
See specializations
SpecializationDescription
Geometry::Mesh<Context::MPI>, Derived
Full specialization
template <
  class Derived>
class FiniteElementSpace<
  Geometry::Mesh< Context::MPI >,
  Derived>;
Represents a finite element space defined on a distributed mesh.
template<class Derived>
class FiniteElementSpacePullbackBase
Base class for mappings taking functions defined on physical elements to reference elements.
template<class Derived>
class FiniteElementSpacePushforwardBase
Base class for inverse mappings taking functions defined on reference elements to physical elements.
struct BoundaryHit
Information passed to a boundary policy when a trajectory reaches the domain boundary.
class DefaultBoundaryPolicy
Default boundary policy for flow maps.
template<class Scalar>
class ReferenceTabulation
Owned scalar basis values and reference derivatives.
template<class Element, class Scalar>
class ReferenceTabulationCache
Bounded reference-table reuse for an element and scalar type.
template<class FES>
class Interpolation
Finite-element interpolation selected by the space's context.
See specializations
SpecializationDescription
FES
Full specialization
template <
  class FES>
requires std::is_same_v<typename FES::ContextType, Context::MPI>
class Interpolation<
  FES> final;
Selects and evaluates distributed interpolation functionals.
class ShapeFunctionBase
Base class for shape function objects.
See declaration
template<class Derived, class FES = typename FormLanguage::Traits<Derived>::FESType, ShapeFunctionSpaceType SpaceType = FormLanguage::Traits<Derived>::SpaceType>
class ShapeFunctionBase
template<class Derived, class FES, ShapeFunctionSpaceType Space>
class ShapeFunction
See specializations
SpecializationDescription
Derived, H1<K, Scalar, Mesh>, Space
Full specialization
template <
  class Derived,
  size_t K,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  H1< K, Scalar, Mesh >,
  Space>;
Shape function expression.
Derived, H1<K, Math::SpatialVector<Scalar>, Mesh>, Space
Full specialization
template <
  class Derived,
  size_t K,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  H1< K, Math::SpatialVector< Scalar >, Mesh >,
  Space>;
Shape function of a vector-valued H1 finite element space.
Derived, H1<K, Math::SpatialMatrix<Scalar>, Mesh>, Space
Full specialization
template <
  class Derived,
  size_t K,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  H1< K, Math::SpatialMatrix< Scalar >, Mesh >,
  Space>;
Matrix-valued shape-function specialization with cached scalar basis tabulation.
Derived, P0<Range, Mesh>, Space
Full specialization
template <
  class Derived,
  class Range,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P0< Range, Mesh >,
  Space>;
Shape function expression.
Derived, P0<Math::SpatialMatrix<Scalar>, Mesh>, Space
Full specialization
template <
  class Derived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P0< Math::SpatialMatrix< Scalar >, Mesh >,
  Space>;
Matrix-valued shape-function specialization with cached scalar basis tabulation.
Derived, P0g<Range, Mesh>, Space
Full specialization
template <
  class Derived,
  class Range,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P0g< Range, Mesh >,
  Space>;
Shape function expression.
Derived, P0g<Math::SpatialMatrix<Scalar>, Mesh>, Space
Full specialization
template <
  class Derived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P0g< Math::SpatialMatrix< Scalar >, Mesh >,
  Space>;
Matrix-valued shape-function specialization with cached scalar basis tabulation.
Derived, P1<Range, Mesh>, Space
Full specialization
template <
  class Derived,
  class Range,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P1< Range, Mesh >,
  Space>;
Shape function expression.
Derived, P1<Math::SpatialMatrix<Scalar>, Mesh>, Space
Full specialization
template <
  class Derived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class ShapeFunction<
  Derived,
  P1< Math::SpatialMatrix< Scalar >, Mesh >,
  Space>;
Matrix-valued shape-function specialization with cached scalar basis tabulation.
template<class Solution, class FES>
class TrialFunction
Represents a function which belongs to a trial space.
template<class FES>
class TestFunction
Represents a function which belongs to a test space.
template<class Derived>
class FunctionBase
Base class for function objects which can be evaluated over a mesh.
template<class T>
class BooleanFunction
See specializations
SpecializationDescription
Boolean
Full specialization
template <>
class BooleanFunction<
  Boolean> final;
Boolean-valued constant function.
template<class Derived>
class IntegerFunctionBase
Base class for objects representing integer functions.
template<class T>
class IntegerFunction
template<class Scalar, class Derived>
class ScalarFunctionBase
Base class for scalar-valued functions with templated scalar type.
template<class Derived>
class RealFunctionBase
Base class for real-valued functions defined on a mesh.
template<class... Values>
class RealFunction
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class RealFunction<
  FunctionBase< NestedDerived >> final;
Real-valued function that wraps another real function expression.
Real
Full specialization
template <>
class RealFunction<
  Real> final;
Represents a constant scalar function with type Real.
Integer
Full specialization
template <>
class RealFunction<
  Integer> final;
Represents a constant scalar function initialized from an Integer.
F
Full specialization
template <
  class F>
class RealFunction<
  F> final;
Represents a scalar function given by an arbitrary scalar function.
template<class... Values>
class ComplexFunction
See specializations
SpecializationDescription
Integer
Full specialization
template <>
class ComplexFunction<
  Integer> final;
Complex-valued constant function built from an integer.
Real
Full specialization
template <>
class ComplexFunction<
  Real> final;
Complex-valued constant function built from a real.
Complex
Full specialization
template <>
class ComplexFunction<
  Complex> final;
Represents a constant scalar function with type Complex.
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class ComplexFunction<
  FunctionBase< NestedDerived >> final;
Complex function wrapper around a nested function.
FunctionBase<RealNestedDerived>, FunctionBase<ImagNestedDerived>
Full specialization
template <
  class RealNestedDerived,
  class ImagNestedDerived>
class ComplexFunction<
  FunctionBase< RealNestedDerived >,
  FunctionBase< ImagNestedDerived >> final;
Complex function built from real and imaginary functions.
F
Full specialization
template <
  class F>
class ComplexFunction<
  F> final;
Represents a scalar function given by an arbitrary scalar function.
FReal, FImag
Full specialization
template <
  class FReal,
  class FImag>
class ComplexFunction<
  FReal,
  FImag> final;
Complex function built from real and imaginary callables.
template<class Scalar, class Derived>
class VectorFunctionBase
Base class for vector-valued functions defined on a mesh.
template<class... Values>
class VectorFunction
See specializations
SpecializationDescription
Math::Vector<Scalar>
Full specialization
template <
  class Scalar>
class VectorFunction<
  Math::Vector< Scalar >> final;
Vector function backed by an existing dense vector.
V, Values...
Full specialization
template <
  class V,
  class... Values>
class VectorFunction<
  V,
  Values...> final;
Represents a vector function which may be constructed from values which can be converted to objects of type RealFunction.
F
Full specialization
template <
  class F>
class VectorFunction<
  F> final;
Vector function backed by a callable.
template<class Scalar, class Derived>
class MatrixFunctionBase
Base class for matrix-valued functions defined on a mesh.
template<class F>
class MatrixFunction
Callable matrix coefficient with explicit row and column extents.
See specializations
SpecializationDescription
Math::Matrix<Scalar>
Full specialization
template <
  class Scalar>
class MatrixFunction<
  Math::Matrix< Scalar >> final;
Matrix-valued constant function.
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
class MatrixFunction<
  Math::SpatialMatrix< Scalar >> final;
Matrix-range finite element or expression specialization.
class GridFunctionBase
Base class for grid function objects.
See declaration
template<class Derived, class FES = typename FormLanguage::Traits<Derived>::FESType, class Data = typename FormLanguage::Traits<Derived>::DataType>
class GridFunctionBase
template<class FES, class Data>
class GridFunction
Represents a grid function belonging to some finite element space.
See specializations
SpecializationDescription
FES, ::Vec
Full specialization
template <
  class FES>
class GridFunction<
  FES,
  ::Vec>;
Grid function specialization storing DOF coefficients in a PETSc vector (Vec).
FES, Math::Vector<…>
Full specialization
template <
  class FES>
class GridFunction<
  FES,
  Math::Vector< typename FormLanguage::Traits< FES >::ScalarType >> final;
Grid function storing its degrees of freedom in a dense Math::Vector over the space's scalar type (the standard local backend).
template<class Vector>
class LinearFormBase
Base class for linear form objects.
template<class FES, class VectorType>
class LinearForm
Represents a linear form on some finite element space.
See specializations
SpecializationDescription
FES, ::Vec
Full specialization
template <
  class FES>
class LinearForm<
  FES,
  ::Vec> final;
Linear form specialization that assembles into a PETSc vector.
FES, Math::Vector<…>
Full specialization
template <
  class FES>
class LinearForm<
  FES,
  Math::Vector< typename FormLanguage::Traits< FES >::ScalarType >> final;
Represents a linear form defined over some finite element space.
template<class Number>
class LinearFormIntegratorBase
Base class for linear form integrators.
template<class Solution, class TrialFES, class TestFES, class OperatorType>
class BilinearForm
Represents a bilinear form on a trial and test space.
See specializations
SpecializationDescription
Solution, TrialFES, TestFES, ::Mat
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES>
class BilinearForm<
  Solution,
  TrialFES,
  TestFES,
  ::Mat> final;
Bilinear form specialization that assembles into a PETSc matrix.
Solution, TrialFES, TestFES, Math::SparseMatrix<Scalar>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Scalar>
class BilinearForm<
  Solution,
  TrialFES,
  TestFES,
  Math::SparseMatrix< Scalar >> final;
Speciallization of BilinearForm for a matrix type.
Solution, TrialFES, TestFES, Math::Matrix<Scalar>
Full specialization
template <
  class Solution,
  class TrialFES,
  class TestFES,
  class Scalar>
class BilinearForm<
  Solution,
  TrialFES,
  TestFES,
  Math::Matrix< Scalar >> final;
Specialization of BilinearForm for a dense matrix operator.
template<class Solution, class TrialFES, class TestFES, class Operator, class CoefficientDerived>
class MassForm
Discrete mass form $ m(u,v) = \int_\Omega c\, u \cdot v\,dx $ .
class HelmholtzForm
Discrete Helmholtz-type form $ h(u,v) = \int_\Omega a\, \nabla u \cdot \nabla v\,dx + \int_\Omega c\, u\, v\,dx $ .
See declaration
template<class Solution, class TrialFES, class TestFES, class Operator, class DiffusionDerived, class MassDerived>
class HelmholtzForm
template<class Range, class Context>
class L2
Arbitrary order $ H^1(\mathcal{T}_h)^d \subset L^2 (\Omega) $ broken Sobolev space.
template<class StrictType>
class FunctionBaseCopy
template<class... Args>
class Zero
See specializations
SpecializationDescription
Scalar
Full specialization
template <
  class Scalar>
class Zero<
  Scalar> final;
Scalar zero function.
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
class Zero<
  Math::SpatialVector< Scalar >> final;
Vector zero function.
template<class Derived, class Operand>
class InterfaceShapeFunctionBase
Evaluation base for a two-sided shape trace.
See specializations
SpecializationDescription
Derived, ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class Derived,
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class InterfaceShapeFunctionBase<
  Derived,
  ShapeFunctionBase< NestedDerived, FES, Space >>;
Two-sided evaluation of a cell-local shape expression.
template<class Operand>
class Jump
See specializations
SpecializationDescription
FunctionBase<FunctionDerived>
Full specialization
template <
  class FunctionDerived>
class Jump<
  FunctionBase< FunctionDerived >> final;
Jump of a FunctionBase instance across an interface.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Jump<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Jump of a ShapeFunctionBase instance across an interface.
template<class Operand>
class Average
See specializations
SpecializationDescription
FunctionBase<FunctionDerived>
Full specialization
template <
  class FunctionDerived>
class Average<
  FunctionBase< FunctionDerived >> final;
Average of a FunctionBase instance across an interface.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Average<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Average of a ShapeFunctionBase instance across an interface.
template<class Base, class Exponent>
class Pow
Represents the power function.
See specializations
SpecializationDescription
FunctionBase<BaseDerived>, Number
Full specialization
template <
  class BaseDerived,
  class Number>
class Pow<
  FunctionBase< BaseDerived >,
  Number> final;
Represents the power function.
template<class Operand>
class Sqrt
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Sqrt<
  FunctionBase< NestedDerived >> final;
Square root operation for functions.
template<class... Args>
class Component
Primary template for Component.
See specializations
SpecializationDescription
FunctionBase<OperandDerived>, size_t
Full specialization
template <
  class OperandDerived>
class Component<
  FunctionBase< OperandDerived >,
  size_t> final;
Extracts a single component from a vector-valued function.
FunctionBase<OperandDerived>, size_t, size_t
Full specialization
template <
  class OperandDerived>
class Component<
  FunctionBase< OperandDerived >,
  size_t,
  size_t> final;
Extracts a single entry from a matrix-valued function.
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
class Component<
  GridFunction< FES, Data >> final;
Extracts a component from a vector-valued GridFunction.
ShapeFunctionBase<OperandDerived, …>
Full specialization
template <
  class OperandDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Component<
  ShapeFunctionBase< OperandDerived, FES, Space >> final;
Extracts a component from a vector-valued ShapeFunction.
ShapeFunctionBase<OperandDerived, …>, size_t, size_t
Full specialization
template <
  class OperandDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Component<
  ShapeFunctionBase< OperandDerived, FES, Space >,
  size_t,
  size_t> final;
Matrix-range finite element or expression specialization.
FunctionBase<Derived>, size_t, size_t, size_t
Full specialization
template <
  class Derived>
class Component<
  FunctionBase< Derived >,
  size_t,
  size_t,
  size_t> final;
One entry of a rank-three tensor-valued function.
ShapeFunctionBase<Derived, FES, Space>, size_t, size_t, size_t
Full specialization
template <
  class Derived,
  class FES,
  ShapeFunctionSpaceType Space>
class Component<
  ShapeFunctionBase< Derived, FES, Space >,
  size_t,
  size_t,
  size_t> final;
One entry of a tensor-valued trial or test basis.
template<class Operand>
class Transpose
Represents the transpose matrix $ A^T $ of some matrix $ A $ .
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Transpose<
  FunctionBase< NestedDerived >> final;
Transpose of a matrix-valued function.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Transpose<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Transpose of a matrix-valued ShapeFunction.
template<class Operand>
class Derivative
See specializations
SpecializationDescription
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType SpaceType>
requires ( !FormLanguage::IsMatrixRange<typename FormLanguage::Traits<FES>::RangeType>::Value)
class Derivative<
  ShapeFunction< NestedDerived, FES, SpaceType >> final;
Partial derivative of a shape function.
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Derivative<
  GridFunction< FES, Data >> final;
Matrix-field derivative, $ D_k A_{ij}=\partial_k A_{ij} $.
ShapeFunction<Derived, FES, Space>
Full specialization
template <
  class Derived,
  class FES,
  ShapeFunctionSpaceType Space>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Derivative<
  ShapeFunction< Derived, FES, Space >> final;
Matrix-basis derivative, $ D_k A_{ij}=\partial_k A_{ij} $.
GridFunction<H1<K, Scalar, Mesh>, Data>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Data>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Derivative<
  GridFunction< H1< K, Scalar, Mesh >, Data >> final;
Derivative of an H1<K> GridFunction.
GridFunction<P1<Range, Mesh>, Data>
Full specialization
template <
  class Range,
  class Data,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
class Derivative<
  GridFunction< P1< Range, Mesh >, Data >> final;
Derivative of a P1 GridFunction.
template<class Operand>
class Grad
Represents the gradient $ \nabla u $ of a scalar function $ u $ .
See specializations
SpecializationDescription
GridFunction<H1<K, Scalar, Mesh>, Data>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Data>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  GridFunction< H1< K, Scalar, Mesh >, Data >> final;
Gradient of a GridFunction on H1<K> space.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  size_t K,
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType SpaceType>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  ShapeFunction< NestedDerived, H1< K, Scalar, Mesh >, SpaceType >> final;
Gradient of a ShapeFunction on H1<K> space.
GridFunction<…>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Data>
class Grad<
  GridFunction< H1< K, Math::SpatialMatrix< Scalar >, Mesh >, Data >> final;
Physical gradient of a matrix H1 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
ShapeFunction<Derived, …>
Full specialization
template <
  size_t K,
  class Scalar,
  class Mesh,
  class Derived,
  ShapeFunctionSpaceType Space>
class Grad<
  ShapeFunction< Derived, H1< K, Math::SpatialMatrix< Scalar >, Mesh >, Space >> final;
Physical gradients of matrix H1 trial or test bases.
GridFunction<P0<Range, Mesh>, Data>
Full specialization
template <
  class Range,
  class Data,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
class Grad<
  GridFunction< P0< Range, Mesh >, Data >> final;
Gradient of a P0 GridFunction.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType SpaceType>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  ShapeFunction< NestedDerived, P0< Scalar, Mesh >, SpaceType >> final;
Gradient of a P0 ShapeFunction.
GridFunction<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
class Grad<
  GridFunction< P0< Math::SpatialMatrix< Scalar >, Mesh >, Data >> final;
Physical gradient of a matrix P0 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
ShapeFunction<Derived, …>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  ShapeFunctionSpaceType Space>
class Grad<
  ShapeFunction< Derived, P0< Math::SpatialMatrix< Scalar >, Mesh >, Space >> final;
Physical gradients of matrix P0 trial or test bases.
GridFunction<P0g<Scalar, Mesh>, Data>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  GridFunction< P0g< Scalar, Mesh >, Data >> final;
Gradient of a P0g grid function.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType SpaceType>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  ShapeFunction< NestedDerived, P0g< Scalar, Mesh >, SpaceType >> final;
Gradient of a P0g shape function.
GridFunction<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
class Grad<
  GridFunction< P0g< Math::SpatialMatrix< Scalar >, Mesh >, Data >> final;
Physical gradient of a matrix P0g solution, with derivative axis last. Uses this family's scalar basis and component ordering.
ShapeFunction<Derived, …>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  ShapeFunctionSpaceType Space>
class Grad<
  ShapeFunction< Derived, P0g< Math::SpatialMatrix< Scalar >, Mesh >, Space >> final;
Physical gradients of matrix P0g trial or test bases.
GridFunction<P1<Scalar, Mesh>, Data>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  GridFunction< P1< Scalar, Mesh >, Data >> final;
Gradient of a P1 grid function.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType SpaceType>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class Grad<
  ShapeFunction< NestedDerived, P1< Scalar, Mesh >, SpaceType >> final;
Gradient of a ShapeFunction.
GridFunction<…>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Data>
class Grad<
  GridFunction< P1< Math::SpatialMatrix< Scalar >, Mesh >, Data >> final;
Physical gradient of a matrix P1 solution, with derivative axis last. Uses this family's scalar basis and component ordering.
ShapeFunction<Derived, …>
Full specialization
template <
  class Scalar,
  class Mesh,
  class Derived,
  ShapeFunctionSpaceType Space>
class Grad<
  ShapeFunction< Derived, P1< Math::SpatialMatrix< Scalar >, Mesh >, Space >> final;
Physical gradients of matrix P1 trial or test bases.
template<class Operand>
class Div
Represents the divergence of a vector valued function.
See specializations
SpecializationDescription
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Div<
  GridFunction< FES, Data >> final;
Matrix-field div, $ (\operatorname{div}A)_i=\sum_j\partial_j A_{ij} $.
ShapeFunction<Derived, FES, Space>
Full specialization
template <
  class Derived,
  class FES,
  ShapeFunctionSpaceType Space>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Div<
  ShapeFunction< Derived, FES, Space >> final;
Matrix-basis div, $ (\operatorname{div}A)_i=\sum_j\partial_j A_{ij} $.
GridFunction<…>
Full specialization
template <
  size_t K,
  class Scalar,
  class Data,
  class Mesh>
class Div<
  GridFunction< H1< K, Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Divergence of an H1 vector GridFunction.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  size_t K,
  class NestedDerived,
  class Number,
  class Mesh,
  ShapeFunctionSpaceType Space>
class Div<
  ShapeFunction< NestedDerived, H1< K, Math::SpatialVector< Number >, Mesh >, Space >> final;
Divergence of an H1 vector ShapeFunction.
GridFunction<…>
Full specialization
template <
  class Scalar,
  class Data,
  class Mesh>
class Div<
  GridFunction< P0g< Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Divergence of a P0g vector GridFunction (identically zero).
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class Div<
  ShapeFunction< NestedDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space >> final;
Divergence of a P0g vector ShapeFunction (identically zero).
GridFunction<…>
Full specialization
template <
  class Scalar,
  class Data,
  class Mesh>
class Div<
  GridFunction< P1< Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Divergence of a P1 vector GridFunction.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class Div<
  ShapeFunction< NestedDerived, P1< Math::SpatialVector< Scalar >, Mesh >, Space >> final;
Divergence of a P1 vector ShapeFunction.
template<class Operand>
class Jacobian
Represents the Jacobian matrix of a type.
See specializations
SpecializationDescription
GridFunction<…>
Full specialization
template <
  size_t K,
  class Scalar,
  class Data,
  class Mesh>
class Jacobian<
  GridFunction< H1< K, Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Jacobian of an H1 vector GridFunction.
ShapeFunction<NestedDerived, …>
Full specialization
template <
  size_t K,
  class NestedDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class Jacobian<
  ShapeFunction< NestedDerived, H1< K, Math::SpatialVector< Scalar >, Mesh >, Space >> final;
Jacobian of an H1 ShapeFunction object.
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Jacobian<
  GridFunction< FES, Data >> final;
Matrix-field jacobian, $ J_{ijk}=\partial_k A_{ij} $.
ShapeFunction<Derived, FES, Space>
Full specialization
template <
  class Derived,
  class FES,
  ShapeFunctionSpaceType Space>
requires FormLanguage::IsMatrixRange< typename FormLanguage::Traits<FES>::RangeType>::Value
class Jacobian<
  ShapeFunction< Derived, FES, Space >> final;
Matrix-basis jacobian, $ J_{ijk}=\partial_k A_{ij} $.
GridFunction<…>
Full specialization
template <
  class Data,
  class Mesh,
  class Scalar>
class Jacobian<
  GridFunction< P0g< Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Jacobian of a P0g vector GridFunction (identically zero).
ShapeFunction<…>
Full specialization
template <
  class ShapeFunctionDerived,
  class Scalar,
  class Mesh,
  ShapeFunctionSpaceType Space>
class Jacobian<
  ShapeFunction< ShapeFunctionDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space >> final;
Jacobian of a P0g vector ShapeFunction (identically zero).
GridFunction<…>
Full specialization
template <
  class Data,
  class Mesh,
  class Scalar>
class Jacobian<
  GridFunction< P1< Math::SpatialVector< Scalar >, Mesh >, Data >> final;
Jacobian of a P1 vector GridFunction.
ShapeFunction<…>
Full specialization
template <
  class ShapeFunctionDerived,
  class Range,
  class Mesh,
  ShapeFunctionSpaceType Space>
requires (!FormLanguage::IsMatrixRange<Range>::Value)
class Jacobian<
  ShapeFunction< ShapeFunctionDerived, P1< Range, Mesh >, Space >> final;
Jacobian of a P1 ShapeFunction object.
template<class Operand>
class Conjugate
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Conjugate<
  FunctionBase< NestedDerived >>;
Complex conjugate of a function.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Conjugate<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Specialization for shape functions.
template<class Operand>
class UnaryMinus
Represent the negation of an operand.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class UnaryMinus<
  FunctionBase< NestedDerived >> final;
Negation of a function.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class UnaryMinus<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Negation of a shape function.
LinearFormIntegratorBase<Number>
Full specialization
template <
  class Number>
class UnaryMinus<
  LinearFormIntegratorBase< Number >> final;
Negation of a linear form integrator.
FormLanguage::List<…>
Full specialization
template <
  class Number>
class UnaryMinus<
  FormLanguage::List< LinearFormIntegratorBase< Number > >>;
Negation of a list of linear form integrators.
LocalBilinearFormIntegratorBase<Number>
Full specialization
template <
  class Number>
class UnaryMinus<
  LocalBilinearFormIntegratorBase< Number >>;
Negation of a bilinear form integrator.
FormLanguage::List<…>
Full specialization
template <
  class Number>
class UnaryMinus<
  FormLanguage::List< LocalBilinearFormIntegratorBase< Number > >>;
Negation of a list of bilinear form integrators.
GlobalBilinearFormIntegratorBase<Number>
Full specialization
template <
  class Number>
class UnaryMinus<
  GlobalBilinearFormIntegratorBase< Number >>;
Negation of a bilinear form integrator.
FormLanguage::List<…>
Full specialization
template <
  class Number>
class UnaryMinus<
  FormLanguage::List< GlobalBilinearFormIntegratorBase< Number > >>;
Negation of a list of bilinear form integrators.
template<class LHS, class RHS>
class Sum
Represents the sum operation.
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Sum<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Addition of two functions.
ShapeFunctionBase<LHSDerived, …>, ShapeFunctionBase<RHSDerived, …>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Sum<
  ShapeFunctionBase< LHSDerived, FES, Space >,
  ShapeFunctionBase< RHSDerived, FES, Space >> final;
Addition of two shape functions.
LinearFormIntegratorBase<LHSNumber>, LinearFormIntegratorBase<RHSNumber>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  LinearFormIntegratorBase< LHSNumber >,
  LinearFormIntegratorBase< RHSNumber >>;
Sum expression.
LinearFormIntegratorBase<LHSNumber>, FormLanguage::List<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  LinearFormIntegratorBase< LHSNumber >,
  FormLanguage::List< LinearFormIntegratorBase< RHSNumber > >>;
Sum of a linear form integrator and a list of them.
FormLanguage::List<…>, LinearFormIntegratorBase<RHSNumber>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >,
  LinearFormIntegratorBase< RHSNumber >>;
Sum of a list of linear form integrators and a single one.
FormLanguage::List<…>, FormLanguage::List<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >,
  FormLanguage::List< LinearFormIntegratorBase< RHSNumber > >>;
Sum of two lists of linear form integrators.
LocalBilinearFormIntegratorBase<…>, LocalBilinearFormIntegratorBase<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  LocalBilinearFormIntegratorBase< LHSNumber >,
  LocalBilinearFormIntegratorBase< RHSNumber >>;
Sum expression.
LocalBilinearFormIntegratorBase<…>, FormLanguage::List<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  LocalBilinearFormIntegratorBase< LHSNumber >,
  FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > >>;
Sum of a bilinear form integrator and a list of them.
FormLanguage::List<…>, LocalBilinearFormIntegratorBase<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >,
  LocalBilinearFormIntegratorBase< RHSNumber >>;
Sum of a list of bilinear form integrators and a single one.
FormLanguage::List<…>, FormLanguage::List<…>
Full specialization
template <
  class LHSNumber,
  class RHSNumber>
class Sum<
  FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >,
  FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > >>;
Sum of two lists of bilinear form integrators.
BilinearFormBase<Operator>, BilinearFormBase<Operator>
Full specialization
template <
  class Operator>
class Sum<
  BilinearFormBase< Operator >,
  BilinearFormBase< Operator >>;
Sum expression.
template<class LHS, class RHS>
class Mult
Represents the multiplication operation.
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Mult<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Multiplication of two FunctionBase instances.
FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, …>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Mult<
  FunctionBase< LHSDerived >,
  ShapeFunctionBase< RHSDerived, FES, Space >> final;
Left Multiplication of a ShapeFunctionBase by a FunctionBase.
ShapeFunctionBase<LHSDerived, …>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Mult<
  ShapeFunctionBase< LHSDerived, FES, Space >,
  FunctionBase< RHSDerived >> final;
Right multiplication of a ShapeFunctionBase by a FunctionBase.
LHS, LocalBilinearFormIntegratorBase<…>
Full specialization
template <
  class LHS,
  class RHSNumber>
class Mult<
  LHS,
  LocalBilinearFormIntegratorBase< RHSNumber >>;
Product expression.
LHS, LinearFormIntegratorBase<RHSNumber>
Full specialization
template <
  class LHS,
  class RHSNumber>
class Mult<
  LHS,
  LinearFormIntegratorBase< RHSNumber >>;
Product expression.
template<class LHS, class RHS>
class Division
Represents the division operation.
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Division<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >>;
Division of a function by another function.
ShapeFunctionBase<LHSDerived, …>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Division<
  ShapeFunctionBase< LHSDerived, FES, Space >,
  FunctionBase< RHSDerived >> final;
Quotient of a shape function.
template<class LHS, class RHS>
class Dot
Represents the dot product between two objects.
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Dot<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Dot product between two functions.
FunctionBase<LHSDerived>, ShapeFunctionBase<RHSDerived, …>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Dot<
  FunctionBase< LHSDerived >,
  ShapeFunctionBase< RHSDerived, FES, Space >> final;
Dot product between a function and a shape function.
ShapeFunctionBase<LHSDerived, …>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Dot<
  ShapeFunctionBase< LHSDerived, FES, Space >,
  FunctionBase< RHSDerived >> final;
Dot product between a shape function and a function.
ShapeFunctionBase<LHSDerived, …>, ShapeFunctionBase<RHSDerived, …>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class Dot<
  ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >,
  ShapeFunctionBase< RHSDerived, TestFES, TestSpace >> final;
Dot product of trial and test shape functions for bilinear forms.
Potential<KernelType, …>, ShapeFunctionBase<RHSDerived, …>
Full specialization
template <
  class KernelType,
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class Dot<
  Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >,
  ShapeFunctionBase< RHSDerived, TestFES, TestSpace >>;
Dot product of a potential with a test shape function.
template<class Operand>
class Abs
Represents the absolute value of a value.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Abs<
  FunctionBase< NestedDerived >>;
Absolute value operation for functions.
template<class Operand>
class Exp
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Exp<
  FunctionBase< NestedDerived >>;
Exponential function operation.
template<class Operand>
class Frobenius
Represents the Frobenius norm.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Frobenius<
  FunctionBase< NestedDerived >>;
Frobenius norm of a function.
template<class Operand>
class Cos
Represents the cosine function.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Cos<
  FunctionBase< NestedDerived >> final;
Cosine function operator for real-valued scalar functions.
template<class Operand>
class Sin
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Sin<
  FunctionBase< NestedDerived >> final;
Sine function operator for real-valued scalar functions.
template<class Operand>
class Cosh
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Cosh<
  FunctionBase< NestedDerived >> final;
Hyperbolic cosine function operator for real-valued scalar functions.
template<class Operand>
class Sinh
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Sinh<
  FunctionBase< NestedDerived >> final;
Hyperbolic sine function operator for real-valued scalar functions.
template<class Operand>
class Tan
Represents the tangent function.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Tan<
  FunctionBase< NestedDerived >>;
Tangent function operator for real-valued scalar functions.
template<class Operand>
class Trace
Represents the trace of a matrix function.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Trace<
  FunctionBase< NestedDerived >> final;
Trace of a FunctionBase instance.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES,
  ShapeFunctionSpaceType Space>
class Trace<
  ShapeFunctionBase< NestedDerived, FES, Space >> final;
Trace of a shape function.
template<class LHS, class RHS>
class Composition
template<class Operand>
class TraceOperator
See specializations
SpecializationDescription
FunctionBase
Full specialization
template <>
class TraceOperator<
  FunctionBase>;
Trace (boundary restriction) operator for functions.
template<class Kernel, class Operand>
class Potential
See specializations
SpecializationDescription
LHS, FunctionBase<RHSDerived>
Full specialization
template <
  class LHS,
  class RHSDerived>
class Potential<
  LHS,
  FunctionBase< RHSDerived >> final;
Potential of a function expression against a kernel.
LHS, ShapeFunctionBase<…>
Full specialization
template <
  class LHS,
  class RHSDerived,
  class FES,
  ShapeFunctionSpaceType SpaceType>
class Potential<
  LHS,
  ShapeFunctionBase< ShapeFunction< RHSDerived, FES, SpaceType >, FES, SpaceType >> final;
template<class... Args>
class Max
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Max<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Represents the maximum operation between two functions.
FunctionBase<NestedDerived>, Real
Full specialization
template <
  class NestedDerived>
class Max<
  FunctionBase< NestedDerived >,
  Real>;
Pointwise maximum of a function expression and a real.
Real, FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Max<
  Real,
  FunctionBase< NestedDerived >>;
Pointwise maximum of a function expression.
template<class... Args>
class Min
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class Min<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Represents the minimum operation between two functions.
FunctionBase<NestedDerived>, Real
Full specialization
template <
  class NestedDerived>
class Min<
  FunctionBase< NestedDerived >,
  Real>;
Pointwise minimum of a function expression.
Real, FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Min<
  Real,
  FunctionBase< NestedDerived >>;
Pointwise minimum of a function expression.
template<class LHS, class RHS>
class LT
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class LT<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Pointwise less-than comparison of two function expressions.
template<class LHS, class RHS>
class GT
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class GT<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Pointwise greater-than comparison of two function expressions.
template<class LHS, class RHS>
class EQ
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class EQ<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Logical EQ operator between two instances of FunctionBase.
template<class LHS, class RHS>
class LEQ
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class LEQ<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Pointwise less-or-equal comparison of two function expressions.
template<class LHS, class RHS>
class GEQ
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class GEQ<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Pointwise greater-or-equal comparison of two function expressions.
template<class LHS, class RHS>
class NEQ
See specializations
SpecializationDescription
FunctionBase<LHSDerived>, FunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class NEQ<
  FunctionBase< LHSDerived >,
  FunctionBase< RHSDerived >> final;
Logical NEQ operator between two instances of FunctionBase.
template<class LHS, class RHS>
class AND
Represents the logical AND expression.
See specializations
SpecializationDescription
BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class AND<
  BooleanFunctionBase< LHSDerived >,
  BooleanFunctionBase< RHSDerived >> final;
Logical AND operator between two boolean functions.
template<class LHS, class RHS>
class OR
See specializations
SpecializationDescription
BooleanFunctionBase<LHSDerived>, BooleanFunctionBase<RHSDerived>
Full specialization
template <
  class LHSDerived,
  class RHSDerived>
class OR<
  BooleanFunctionBase< LHSDerived >,
  BooleanFunctionBase< RHSDerived >> final;
Logical OR operator between two instances of BooleanFunctionBase.
template<class Integrand>
class QuadratureRule
See specializations
SpecializationDescription
ShapeFunctionBase<…>
Full specialization
template <
  size_t K,
  class NestedDerived,
  class Scalar,
  class Mesh>
class QuadratureRule<
  ShapeFunctionBase< ShapeFunction< NestedDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace >>;
Specialization for $\int v \ dx$ with an H1 test shape function.
ShapeFunctionBase<…>
Full specialization
template <
  size_t K,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
class QuadratureRule<
  ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace > >, H1< K, Scalar, Mesh >, TestSpace >>;
Specialization for $\int f \cdot v \ dx$ with an H1 test shape function.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int u \cdot v \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LeftOperand,
  class RightOperand,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (H1MassOperands<Mult<LeftOperand, RightOperand>>::Value && std::is_same_v<typename H1MassOperands< Mult<LeftOperand, RightOperand>>::MultiplicandType::FESType, H1<KTrial, Scalar, Mesh>>)
class QuadratureRule<
  Dot< ShapeFunctionBase< Mult< LeftOperand, RightOperand >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Weighted mass quadrature for plain H1 trial and test leaves.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (((!FormLanguage::IsMatrixRange<Scalar>::Value)) && (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value))
class QuadratureRule<
  Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int (A \nabla u) \cdot \nabla v \ dx$ with H1 trial and test shape functions.
Mult<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value)
class QuadratureRule<
  Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >>;
Specialization for $\int c \, (u \cdot v) \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LHSDerived,
  class RHSDerived,
  class TrialRange,
  class TestRange,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<TrialRange>::Value && !FormLanguage::IsMatrixRange<TestRange>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Div< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace > >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace >, H1< KTest, TestRange, Mesh >, TestSpace > >>;
Specialization for $\int \nabla \cdot u \, q \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LHSDerived,
  class RHSDerived,
  class TrialRange,
  class TestRange,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<TrialRange>::Value && !FormLanguage::IsMatrixRange<TestRange>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< Div< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace > >, H1< KTest, TestRange, Mesh >, TestSpace > >>;
Specialization for $\int p \, \nabla \cdot v \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value && !FormLanguage::IsMatrixRange<Scalar>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int (A J u) : J v \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int \nabla u \cdot \nabla v \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int J u : J v \ dx$ with H1 trial and test shape functions.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class CoeffDerived,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Dot< FunctionBase< CoeffDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Dot< FunctionBase< CoeffDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Integration of a rank-one form in the H1 Jacobian of ShapeFunction.
Dot<…>
Full specialization
template <
  size_t KTrial,
  size_t KTest,
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class Scalar,
  class Mesh>
requires (!FormLanguage::IsMatrixRange<Scalar>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Mult< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, FunctionBase< CoefficientDerived > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > >>;
Specialization for $\int (\mathbf{J}\,u \cdot f) \cdot v \ dx$ with H1 trial and test shape functions.
ShapeFunctionBase<…>
Full specialization
template <
  class NestedDerived,
  class Range,
  class Mesh>
class QuadratureRule<
  ShapeFunctionBase< ShapeFunction< NestedDerived, P1< Range, Mesh >, TestSpace >, P1< Range, Mesh >, TestSpace >>;
Integration of a P1 ShapeFunction.
ShapeFunctionBase<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class Range,
  class Mesh>
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.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< LHSRange, LHSMesh >, TrialSpace >, P1< LHSRange, LHSMesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< RHSRange, RHSMesh >, TestSpace >, P1< RHSRange, RHSMesh >, TestSpace > >>;
Integration of the isotropic Dot product of two instances of the P1 ShapeFunction.
Dot<…>
Full specialization
template <
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value)
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.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (!FormLanguage::IsMatrixRange<LHSRange>::Value)
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.
Dot<…>
Full specialization
template <
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (((!FormLanguage::IsMatrixRange<LHSRange>::Value)) && (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value))
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.
Mult<…>
Full specialization
template <
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value)
class QuadratureRule<
  Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< LHSRange, LHSMesh >, TrialSpace >, P1< LHSRange, LHSMesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< RHSRange, RHSMesh >, TestSpace >, P1< RHSRange, RHSMesh >, TestSpace > > >>;
Specialization for $\int c \, (u \cdot v) \ dx$ in the case of P1 shape functions.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class LHSMesh,
  class RHSMesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< Div< ShapeFunction< LHSDerived, P1< Math::SpatialVector< Real >, LHSMesh >, TrialSpace > >, P1< Math::SpatialVector< Real >, LHSMesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Real, RHSMesh >, TestSpace >, P1< Real, RHSMesh >, TestSpace > >>;
Specialization for $\int (\nabla \cdot u)\, q \ dx$ in the case of P1 shape functions.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class LHSMesh,
  class RHSMesh>
class QuadratureRule<
  Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Real, LHSMesh >, TrialSpace >, P1< Real, LHSMesh >, TrialSpace >, ShapeFunctionBase< Div< ShapeFunction< RHSDerived, P1< Math::SpatialVector< Real >, RHSMesh >, TestSpace > >, P1< Math::SpatialVector< Real >, RHSMesh >, TestSpace > >>;
Specialization for $\int p \, (\nabla \cdot v)\, dx$ in the case of P1 shape functions.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (FormLanguage::IsVectorRange<LHSRange>::Value && FormLanguage::IsVectorRange<RHSRange>::Value)
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.
Dot<…>
Full specialization
template <
  class CoeffDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (FormLanguage::IsVectorRange<LHSRange>::Value && FormLanguage::IsVectorRange<RHSRange>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Dot< FunctionBase< CoeffDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, P1< LHSRange, LHSMesh >, TrialSpace > >, P1< LHSRange, LHSMesh >, TrialSpace > >, P1< LHSRange, LHSMesh >, TrialSpace >, ShapeFunctionBase< Dot< FunctionBase< CoeffDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, P1< RHSRange, RHSMesh >, TestSpace > >, P1< RHSRange, RHSMesh >, TestSpace > >, P1< RHSRange, RHSMesh >, TestSpace > >>;
Integration of a rank-one form in the P1 Jacobian of ShapeFunction.
Dot<…>
Full specialization
template <
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value && !FormLanguage::IsMatrixRange<LHSRange>::Value && !FormLanguage::IsMatrixRange<RHSRange>::Value)
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.
Dot<…>
Full specialization
template <
  class CoefficientDerived,
  class LHSDerived,
  class RHSDerived,
  class LHSRange,
  class RHSRange,
  class LHSMesh,
  class RHSMesh>
requires (!FormLanguage::IsTensorRange<typename FormLanguage::Traits< FunctionBase<CoefficientDerived>>::RangeType>::Value && !FormLanguage::IsMatrixRange<LHSRange>::Value && !FormLanguage::IsMatrixRange<RHSRange>::Value)
class QuadratureRule<
  Dot< ShapeFunctionBase< Mult< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, P1< LHSRange, LHSMesh >, TrialSpace > >, P1< LHSRange, LHSMesh >, TrialSpace >, FunctionBase< CoefficientDerived > >, P1< LHSRange, LHSMesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< RHSRange, RHSMesh >, TestSpace >, P1< RHSRange, RHSMesh >, TestSpace > >>;
Specialization for $ \int (\nabla u \cdot f) \cdot v $ in the case of P1 shape functions.
Dot<…>
Full specialization
template <
  class Kernel,
  class Range,
  class Mesh,
  class LHSDerived,
  class RHSDerived>
class QuadratureRule<
  Dot< Potential< Kernel, ShapeFunctionBase< LHSDerived, P1< Range, Mesh >, TrialSpace > >, ShapeFunctionBase< RHSDerived, P1< Range, Mesh >, TestSpace > >>;
Specialization for $\int \mathcal{K}(u) \cdot v$ in the case of P1 trial/test shape functions.
FunctionBase<FunctionDerived>
Full specialization
template <
  class FunctionDerived>
class QuadratureRule<
  FunctionBase< FunctionDerived >> final;
Quadrature rule for integrating general functions on mesh polytopes.
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
class QuadratureRule<
  GridFunction< FES, Data >>;
Integration of a scalar grid function over a mesh region.
Dot<…>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class QuadratureRule<
  Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >>;
Local bilinear-form quadrature for the dot product of a trial and a test shape function.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES>
class QuadratureRule<
  ShapeFunctionBase< NestedDerived, FES, TestSpace >>;
Local linear-form quadrature for a test shape function expression.
template<class Integrand>
class Integral
Represents mathematical expressions of the integral operator on a domain.
See specializations
SpecializationDescription
Dot<…>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class Integral<
  Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >> final;
Integration of the dot product of a trial and test operators.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES>
requires ( std::is_same_v<typename FormLanguage::Traits< ShapeFunctionBase<NestedDerived, FES, TestSpace>>::RangeType, typename FormLanguage::Traits< ShapeFunctionBase<NestedDerived, FES, TestSpace>>::ScalarType>)
class Integral<
  ShapeFunctionBase< NestedDerived, FES, TestSpace >> final;
Integration of a test operator.
GridFunction<FES, Data>
Full specialization
template <
  class FES,
  class Data>
class Integral<
  GridFunction< FES, Data >> final;
Integration of a GridFunction object.
Dot<…>
Full specialization
template <
  class Kernel,
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class Integral<
  Dot< Potential< Kernel, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >> final;
Integral of a potential tested against a shape function.
template<class Integrand>
class FaceIntegral
Represents expressions of the integral operator on the faces of a mesh.
See specializations
SpecializationDescription
Dot<…>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class FaceIntegral<
  Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >> final;
Integration of the dot product of a trial and test operators.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES>
class FaceIntegral<
  ShapeFunctionBase< NestedDerived, FES, TestSpace >> final;
Integration of a test operator.
template<class Integrand>
class BoundaryIntegral
Represents expressions of the integral operator on the boundary of a domain.
See specializations
SpecializationDescription
Dot<…>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class BoundaryIntegral<
  Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >> final;
Integration of the dot product of a trial and test operators.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES>
class BoundaryIntegral<
  ShapeFunctionBase< NestedDerived, FES, TestSpace >> final;
Integration of a test operator.
template<class Integrand>
class InterfaceIntegral
Represents expressions of the integral operator on the interface of a domain.
See specializations
SpecializationDescription
Dot<…>
Full specialization
template <
  class LHSDerived,
  class TrialFES,
  class RHSDerived,
  class TestFES>
class InterfaceIntegral<
  Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >> final;
Integration of the dot product of a trial and test operators.
ShapeFunctionBase<NestedDerived, …>
Full specialization
template <
  class NestedDerived,
  class FES>
class InterfaceIntegral<
  ShapeFunctionBase< NestedDerived, FES, TestSpace >> final;
Integration of a test operator.
template<class Operand, class Value>
class DirichletBC
See specializations
SpecializationDescription
TrialFunction<Solution, FES>, FunctionBase<ValueDerived>
Full specialization
template <
  class Solution,
  class FES,
  class ValueDerived>
class DirichletBC<
  TrialFunction< Solution, FES >,
  FunctionBase< ValueDerived >> final;
Value-prescribing Dirichlet boundary condition, $ u = g $.
TrialFunction<Solution, FES1>, ShapeFunctionBase<Derived2, FES2, Sp>
Full specialization
template <
  class Solution,
  class FES1,
  class Derived2,
  class FES2,
  ShapeFunctionSpaceType Sp>
class DirichletBC<
  TrialFunction< Solution, FES1 >,
  ShapeFunctionBase< Derived2, FES2, Sp >> final;
Identification Dirichlet boundary condition, $ u = A(v) $ or $ u = A(v) + d $.
template<class Operand, class... Parameters>
class PeriodicBC
See specializations
SpecializationDescription
TrialFunction<Solution, FES>, IndexMap<IndexSet>
Full specialization
template <
  class Solution,
  class FES>
class PeriodicBC<
  TrialFunction< Solution, FES >,
  IndexMap< IndexSet >> final;
Represents a Peridodic boundary condition on a ShapeFunction object.
template<class Operator, class Vector, class Scalar>
class ProblemBody
Accumulated bilinear forms, linear forms and boundary conditions of a Problem.
See specializations
SpecializationDescription
void, void, Scalar
Full specialization
template <
  class Scalar>
class ProblemBody<
  void,
  void,
  Scalar>;
Problem body containing only integrators and boundary conditions.
Operator, void, Scalar
Full specialization
template <
  class Operator,
  class Scalar>
class ProblemBody<
  Operator,
  void,
  Scalar>;
Problem body containing operator terms only.
void, Vector, Scalar
Full specialization
template <
  class Vector,
  class Scalar>
class ProblemBody<
  void,
  Vector,
  Scalar>;
Problem body containing vector terms only.
template<class Scalar>
class ProblemBodyBase
Base class representing the body of a variational problem.
template<class... Parameters>
class Problem
Represents a variational problem.
See specializations
SpecializationDescription
PETSc::Math::LinearSystem, U, V
Full specialization
template <
  class U,
  class V>
class Problem<
  PETSc::Math::LinearSystem,
  U,
  V>;
PETSc variational problem for a single trial / test function pair.
PETSc::Math::LinearSystem, U1, U2, U3, Us...
Full specialization
template <
  class U1,
  class U2,
  class U3,
  class... Us>
class Problem<
  PETSc::Math::LinearSystem,
  U1,
  U2,
  U3,
  Us...>;
PETSc variational problem for multiple coupled trial / test functions.
LinearSystem, TrialFunction, TestFunction
Full specialization
template <
  class LinearSystem,
  class TrialFunction,
  class TestFunction>
class Problem<
  LinearSystem,
  TrialFunction,
  TestFunction>;
Two-field variational problem.
LinearSystem, U1, U2, U3, Us...
Full specialization
template <
  class LinearSystem,
  class U1,
  class U2,
  class U3,
  class... Us>
class Problem<
  LinearSystem,
  U1,
  U2,
  U3,
  Us...>;
Variational problem with three or more trial/test functions.
template<class LinearSystem>
class ProblemBase
Base class for variational problem objects.
template<class Operand, class VectorField, class Step, class BoundaryPolicy>
class Flow
Primary template for Flow.
See specializations
SpecializationDescription
FunctionBase<Derived>, VectorField, Step, BoundaryPolicy
Full specialization
template <
  class Derived,
  class VectorField,
  class Step,
  class BoundaryPolicy>
class Flow<
  FunctionBase< Derived >,
  VectorField,
  Step,
  BoundaryPolicy>;
Flow map operator for functions.
template<class Operand, class Derived>
class GradBase
Base class for gradient operator implementations.
See specializations
SpecializationDescription
GridFunction<FES, Data>, Derived
Full specialization
template <
  class FES,
  class Data,
  class Derived>
class GradBase<
  GridFunction< FES, Data >,
  Derived>;
Gradient operator for grid functions.
template<class Derived>
class GridFunctionBaseReference
Base class for discrete finite element functions.
template<size_t K>
class DubinerTriangle
Dubiner orthogonal modal basis on the reference triangle.
template<size_t K>
class VandermondeTriangle
Vandermonde matrix for nodal-to-modal transformation on triangles.
template<size_t K>
class DubinerTetrahedron
Dubiner orthogonal modal basis on the reference tetrahedron.
template<size_t K>
class VandermondeTetrahedron
Vandermonde matrix of the Dubiner basis on the reference tetrahedron.
template<size_t K>
class FeketeTriangle
Cached Fekete-type nodes on the reference triangle for degree K.
template<size_t K>
class FeketeTetrahedron
Cached Fekete-type nodes on the reference tetrahedron for degree K.
template<size_t K, class Scalar>
class H1Element
Degree k H1-conforming Lagrange element.
See specializations
SpecializationDescription
K, Math::SpatialVector<Scalar>
Full specialization
template <
  size_t K,
  class Scalar>
class H1Element<
  K,
  Math::SpatialVector< Scalar >> final;
Continuous H1-conforming piecewise polynomial (degree k) vector Lagrange element.
K, Math::SpatialMatrix<Scalar>
Full specialization
template <
  size_t K,
  class Scalar>
class H1Element<
  K,
  Math::SpatialMatrix< Scalar >> final;
Matrix-valued reference element built from scalar nodal functionals.
template<size_t K, class Range, class Mesh>
class H1
Degree K H1-conforming Lagrange finite element space.
See specializations
SpecializationDescription
K, Scalar, Geometry::Mesh<Context::MPI>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Scalar,
  Geometry::Mesh< Context::MPI >>;
Distributed H1 finite element space for MPI meshes (scalar range).
K, Math::SpatialVector<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::MPI >>;
Distributed vector-valued H1 finite element space for MPI meshes.
K, Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::MPI >> final;
Matrix-range finite element or expression specialization.
K, Scalar, Geometry::Mesh<Context::Local>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Scalar,
  Geometry::Mesh< Context::Local >>;
Degree K H1-conforming Lagrange finite element space.
K, Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Vector-valued continuous piecewise polynomial (degree K) Lagrange finite element space.
K, Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  size_t K,
  class Scalar>
class H1<
  K,
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Matrix-valued finite element space with component-wise scalar basis replication.
template<size_t K>
class GLL
Compile-time Gauss–Lobatto–Legendre (GLL) nodes on [-1, 1].
template<size_t K>
class LegendrePolynomial
Compile-time degree Legendre polynomial evaluator.
template<size_t K>
class LagrangeBasis1D
Generic 1D Lagrange basis on arbitrary nodes.
template<size_t K>
class LagrangeBasisPoint
Lagrange basis on the reference point (0D element).
template<size_t K>
class LagrangeBasisSegment
Lagrange basis on the reference segment [0,1] using GLL nodes.
template<size_t K>
class LagrangeBasisTriangle
Lagrange basis on the reference triangle.
template<size_t K>
class LagrangeBasisTetrahedron
Lagrange basis on the reference tetrahedron.
template<size_t K>
class LagrangeBasisQuadrilateral
Lagrange basis on the reference quadrilateral [0,1]².
template<size_t K>
class LagrangeBasisWedge
Lagrange basis on the reference wedge (triangular prism).
template<size_t K>
class GLL01
Gauss–Lobatto–Legendre nodes mapped from [-1, 1] to [0, 1].
template<size_t K>
struct PyramidIndex
Indexing of the tensor-product modes on the reference pyramid.
template<size_t K>
class BernsteinPyramid
Bernstein basis on the reference pyramid.
template<size_t K>
class PyramidModal
Modal basis on the reference pyramid.
template<size_t K>
class VandermondePyramid
Vandermonde matrix of the modal basis on the reference pyramid.
template<size_t K>
class JacobiPolynomial
Jacobi polynomial evaluator.
template<class Expression>
struct H1MassOperands
Certifies the plain-leaf operands of an H1 weighted mass expression.
See specializations
SpecializationDescription
Mult<…>
Full specialization
template <
  size_t K,
  class CoefficientDerived,
  class Derived,
  class Range,
  class Mesh>
struct H1MassOperands<
  Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< ShapeFunction< Derived, H1< K, Range, Mesh >, TrialSpace >, H1< K, Range, Mesh >, TrialSpace > >>;
Retains the existing left-coefficient mass applicability.
Mult<…>
Full specialization
template <
  size_t K,
  class Derived,
  class Range,
  class Mesh,
  class CoefficientDerived>
struct H1MassOperands<
  Mult< ShapeFunctionBase< ShapeFunction< Derived, H1< K, Range, Mesh >, TrialSpace >, H1< K, Range, Mesh >, TrialSpace >, FunctionBase< CoefficientDerived > >>;
Certifies scalar right scaling of aggregate H1 carriers.
template<size_t K>
class WarpFactor1D
Computes the 1D warp factor for moving equispaced nodes to GLL positions.
template<size_t K>
class TriangleBlend
Optimized blending parameter α for triangular warp-blend.
template<size_t K>
class TetrahedronBlend
Optimized blending parameter α for tetrahedral warp-blend.
template<size_t K>
class WarpShiftFace2D
Computes 2D warp-blend shift for a triangular face.
template<size_t K>
class WarpShiftFace3D
Computes 3D warp-blend shift for a tetrahedral face.
template<size_t K>
class WarpBlendTriangle
Applies warp-blend algorithm to move triangle nodes toward Fekete positions.
template<size_t K>
class WarpBlendTetrahedron
Applies warp-blend algorithm to move tetrahedron nodes toward Fekete positions.
class IdentityMatrix
Represents the identity matrix function $ I_n $ .
template<class Operand>
class Im
Extracts the imaginary part of a complex-valued function.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Im<
  FunctionBase< NestedDerived >>;
Specialization for FunctionBase operands.
class IntegrationPoint
Evaluation point used by variational operators.
class Integrator
Abstract base class for integrators in variational formulations.
template<class Operand, class Derived>
class JacobianBase
Base class for Jacobian matrix operator implementations.
See specializations
SpecializationDescription
GridFunction<FES, Data>, Derived
Full specialization
template <
  class FES,
  class Data,
  class Derived>
class JacobianBase<
  GridFunction< FES, Data >,
  Derived>;
Jacobian of a P1 GridFunction.
template<class Derived>
class LagrangeFiniteElementBase
Common reference-space properties of Lagrange element families.
template<class Operator>
class NamedFormStorage
Owns the operator of a named bilinear form.
See specializations
SpecializationDescription
::Mat
Full specialization
template <>
class NamedFormStorage<
  ::Mat>;
Owns a named form's PETSc matrix, copying values and transferring moves.
template<class Derived>
class NonLinearFormIntegrator
CRTP mixin for nonlinear form integrators.
template<class Scalar>
class P0Element
Degree 0 Lagrange element.
See specializations
SpecializationDescription
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
class P0Element<
  Math::SpatialVector< Scalar >> final;
Piecewise constant (degree 0) vector Lagrange element.
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
class P0Element<
  Math::SpatialMatrix< Scalar >> final;
Matrix-valued reference element built from scalar nodal functionals.
template<class Range, class Mesh>
class P0
Degree 0 Lagrange finite element space.
See specializations
SpecializationDescription
Range, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Range>
class P0<
  Range,
  Geometry::Mesh< Context::MPI >>;
Distributed P0 finite element space for MPI meshes.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Scalar>
class P0<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::MPI >> final;
Matrix-range finite element or expression specialization.
Scalar, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0<
  Scalar,
  Geometry::Mesh< Context::Local >> final;
Scalar-valued piecewise constant (P0) Lagrange finite element space.
Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0<
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Cellwise constant vector space with independent component DOFs.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
class P0<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Matrix-valued finite element space with component-wise scalar basis replication.
template<class Scalar>
class P0gElement
Forward declaration of global P0 finite elements.
See specializations
SpecializationDescription
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
class P0gElement<
  Math::SpatialVector< Scalar >> final;
Vector-valued cellwise-constant finite element.
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
class P0gElement<
  Math::SpatialMatrix< Scalar >> final;
Matrix-valued reference element built from scalar nodal functionals.
template<class Range, class Mesh>
class P0g
Forward declaration of global constant finite element spaces.
See specializations
SpecializationDescription
Scalar, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0g<
  Scalar,
  Geometry::Mesh< Context::MPI >> final;
Distributed scalar P0g finite element space for MPI meshes.
Math::SpatialVector<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0g<
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::MPI >> final;
Distributed vector P0g finite element space for MPI meshes.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Scalar>
class P0g<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::MPI >> final;
Matrix-range finite element or expression specialization.
Scalar, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0g<
  Scalar,
  Geometry::Mesh< Context::Local >> final;
Cellwise-constant scalar finite element space with a global basis.
Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
requires (std::is_same_v<Scalar, Real> || std::is_same_v<Scalar, Complex>)
class P0g<
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Cellwise-constant vector-valued finite element space with a global basis.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
class P0g<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Matrix-range finite element or expression specialization.
template<class Scalar>
class P1Element
Degree 1 Lagrange element.
See specializations
SpecializationDescription
Math::SpatialVector<Scalar>
Full specialization
template <
  class Scalar>
class P1Element<
  Math::SpatialVector< Scalar >> final;
Continuous piecewise linear (degree 1) vector Lagrange element.
Math::SpatialMatrix<Scalar>
Full specialization
template <
  class Scalar>
class P1Element<
  Math::SpatialMatrix< Scalar >> final;
Matrix-valued reference element built from scalar nodal functionals.
template<class Range, class Mesh>
class P1
Degree 1 Lagrange finite element space.
See specializations
SpecializationDescription
Range, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Range>
class P1<
  Range,
  Geometry::Mesh< Context::MPI >>;
Distributed P1 finite element space for MPI meshes.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::MPI>
Full specialization
template <
  class Scalar>
class P1<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::MPI >> final;
Matrix-range finite element or expression specialization.
Scalar, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
class P1<
  Scalar,
  Geometry::Mesh< Context::Local >>;
Real valued Lagrange finite element space.
Math::SpatialVector<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
class P1<
  Math::SpatialVector< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Vector-valued continuous piecewise linear Lagrange finite element space.
Math::SpatialMatrix<Scalar>, Geometry::Mesh<Context::Local>
Full specialization
template <
  class Scalar>
class P1<
  Math::SpatialMatrix< Scalar >,
  Geometry::Mesh< Context::Local >> final;
Matrix-valued finite element space with component-wise scalar basis replication.
template<class Scalar>
class PeriodicBCBase
Abstract base class for a periodic boundary condition.
template<class LinearSystem, class U, class V>
class ProblemUVBase
General class to assemble linear systems with Operator and Vector generic types in a sequential context.
template<class LinearSystem, class U1, class U2, class U3, class... Us>
class ProblemUsBase
Base for mixed variational problems with three or more functions.
template<class Operand>
class Re
Extracts the real part of a complex-valued function.
See specializations
SpecializationDescription
FunctionBase<NestedDerived>
Full specialization
template <
  class NestedDerived>
class Re<
  FunctionBase< NestedDerived >>;
Specialization for FunctionBase operands.
class RelativeError
Utility class for computing relative errors.
template<class T>
struct IsTrialFunction
Type trait to check if a type is a TrialFunction.
See specializations
SpecializationDescription
PETSc::Variational::TrialFunction<Solution, …>
Full specialization
template <
  class Solution,
  class FES>
struct IsTrialFunction<
  PETSc::Variational::TrialFunction< Solution, FES >>;
Marks PETSc trial functions as valid trial functions.
TrialFunction<Solution, FES>
Full specialization
template <
  class Solution,
  class FES>
struct IsTrialFunction<
  TrialFunction< Solution, FES >>;
Specialization for TrialFunction types.
template<class T>
struct IsTestFunction
Type trait to check if a type is a TestFunction.
See specializations
SpecializationDescription
PETSc::Variational::TestFunction<FES>
Full specialization
template <
  class FES>
struct IsTestFunction<
  PETSc::Variational::TestFunction< FES >>;
Marks PETSc test functions as valid test functions.
TestFunction<FES>
Full specialization
template <
  class FES>
struct IsTestFunction<
  TestFunction< FES >>;
Specialization for TestFunction types.
template<class ... Parameters>
class SparseProblem
See specializations
SpecializationDescription
LinearSystem, U, V
Full specialization
template <
  class LinearSystem,
  class U,
  class V>
class SparseProblem<
  LinearSystem,
  U,
  V>;
General class to assemble linear systems with Math::SparseMatrix and Math::Vector types in a serial context.
template<class Value>
class TensorFunction
Tensor coefficient with value semantics.
template<class Solution, class FES>
class TrialFunctionReference
Reference wrapper for trial functions.

Enums

enum class ShapeFunctionSpaceType { Trial, Test }
Enumeration for shape function space types.
enum class AssemblyTarget { LHS, RHS }
Target for partial problem assembly.

Typedefs

template<class Scalar>
using EssentialBoundary = FormLanguage::List<DirichletBCBase<Scalar>>
Alias for a list of Dirichlet boundary conditions.
template<size_t K>
using RealH1Element = H1Element<K, Real>
Convenience alias for real-valued H1 element.
template<size_t K>
using ComplexH1Element = H1Element<K, Complex>
Convenience alias for complex-valued H1 element.
template<size_t K>
using VectorH1Element = H1Element<K, Math::SpatialVector<Real>>
Convenience alias for real vector-valued H1 element.
template<size_t K>
using ComplexVectorH1Element = H1Element<K, Math::SpatialVector<Complex>>
Convenience alias for complex vector-valued H1 element.
template<size_t K, class Mesh>
using RealH1 = H1<K, Real, Mesh>
Alias for a scalar real-valued H1 finite element space.
template<size_t K, class Mesh>
using ComplexH1 = H1<K, Complex, Mesh>
Alias for a scalar complex-valued H1 finite element space.
template<size_t K, class Mesh>
using VectorH1 = H1<K, Math::SpatialVector<Real>, Mesh>
Alias for a vector-valued real H1 finite element space.
template<size_t K, class Mesh>
using MatrixH1 = H1<K, Math::SpatialMatrix<Real>, Mesh>
Matrix-valued continuous finite element space of compile-time degree.
using RealP0Element = P0Element<Real>
Alias for P0Element<Real>.
using ComplexP0Element = P0Element<Complex>
Alias for P0Element<Complex>.
template<class Scalar>
using VectorP0Element = P0Element<Math::SpatialVector<Scalar>>
Alias for P0Element<Math::SpatialVector<Scalar>>.
using RealVectorP0Element = VectorP0Element<Real>
Alias for real vector P0Element.
using ComplexVectorP0Element = VectorP0Element<Complex>
Alias for complex vector P0Element.
template<class Mesh>
using RealP0 = P0<Real, Mesh>
Alias for a scalar real-valued P0 finite element space.
template<class Mesh>
using ComplexP0 = P0<Complex, Mesh>
Alias for a scalar complex-valued P0 finite element space.
template<class Mesh>
using MatrixP0 = P0<Math::SpatialMatrix<Real>, Mesh>
Matrix-valued discontinuous constant finite element space.
template<class Mesh>
using RealP0g = P0g<Real, Mesh>
Cellwise-constant real space with a global basis.
template<class Mesh>
using ComplexP0g = P0g<Complex, Mesh>
Cellwise-constant complex space with a global basis.
template<class Mesh>
using VectorP0g = P0g<Math::SpatialVector<Real>, Mesh>
Cellwise-constant vector-valued space with a global basis.
template<class Mesh>
using MatrixP0g = P0g<Math::SpatialMatrix<Real>, Mesh>
Matrix-valued globally constant finite element space.
using RealP1Element = P1Element<Real>
Alias for P1Element<Real>.
using ComplexP1Element = P1Element<Complex>
Alias for P1Element<Complex>.
template<class Scalar>
using VectorP1Element = P1Element<Math::SpatialVector<Scalar>>
Alias for P1Element<Math::SpatialVector<Scalar>>.
using RealVectorP1Element = P1Element<Math::SpatialVector<Real>>
Alias for real vector P1Element.
template<class Mesh>
using RealP1 = P1<Real, Mesh>
Alias for a scalar real-valued P1 finite element space.
template<class Mesh>
using ComplexP1 = P1<Complex, Mesh>
Alias for a scalar complex-valued P1 finite element space.
template<class Mesh>
using VectorP1 = P1<Math::SpatialVector<Real>, Mesh>
Alias for a vector-valued real P1 finite element space.
template<class Mesh>
using MatrixP1 = P1<Math::SpatialMatrix<Real>, Mesh>
Matrix-valued continuous linear finite element space.
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
using P1DivTrialIntegrand = Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>>, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Real, RHSMesh>, TestSpace>, P1<Real, RHSMesh>, TestSpace>>
Integrand type of the P1 divergence trial term.
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
using P1DivTestIntegrand = Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Real, LHSMesh>, TrialSpace>, P1<Real, LHSMesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>
Integrand type of the P1 divergence test term.
template<class Scalar>
using PeriodicBoundary = FormLanguage::List<PeriodicBCBase<Scalar>>
Alias for a list of peridodic boundary conditions.
template<class Scalar>
using VectorZero = Zero<Math::SpatialVector<Scalar>>
Convenience typedef for vector zero function.

Functions

Interpolation
Deduces the space that defines the interpolation functionals.
See declaration
template<class FES, class Pred>
Interpolation(const FES& fes, Geometry::Region region, const Pred& pred) -> Interpolation< FES >
BilinearForm
Deduction guide for PETSc-backed BilinearForm.
See declaration
template<class Solution, class TrialFES, class TestFES>
BilinearForm(const PETSc::Variational::TrialFunction<Solution, TrialFES>& u, const PETSc::Variational::TestFunction<TestFES>& v) -> BilinearForm< Solution, TrialFES, TestFES, ::Mat >
template<class FES>
LinearForm(const PETSc::Variational::TestFunction<FES>& test) -> LinearForm< FES, ::Vec >
Deduction guide for PETSc-backed LinearForm.
operator-
Subtracts an owned PETSc bilinear-form snapshot.
See declaration
template<class Vector, class Scalar>
auto operator-(const ProblemBody<::Mat, Vector, Scalar>& pb, const BilinearFormBase<::Mat>& bf) -> auto
operator+
Adds a PETSc linear form to the residual, hence negates its load.
See declaration
template<class Operator, class Scalar>
auto operator+(const ProblemBody<Operator, ::Vec, Scalar>& pb, const LinearFormBase<::Vec>& lf) -> auto
Problem
Deduction guide for two-field PETSc Problem.
See declaration
template<class Solution, class TrialFES, class TestFES>
Problem(PETSc::Variational::TrialFunction<Solution, TrialFES>& u, PETSc::Variational::TestFunction<TestFES>& v) -> Problem< PETSc::Math::LinearSystem, TrialFunction< Solution, TrialFES >, TestFunction< TestFES > >
Problem
Deduction guide for multi-field PETSc Problem.
See declaration
template<class U1, class U2, class U3, class... Us>
Problem(U1& u1, U2& u2, U3& u3, Us&... us) -> Problem< Rodin::PETSc::Math::LinearSystem, U1, U2, U3, Us... >
LinearElasticityForm
Deduction guide for two function Lamé parameters.
See declaration
template<class LambdaDerived, class MuDerived, class Solution, class FES>
LinearElasticityForm(const FunctionBase<LambdaDerived>& lambda, const FunctionBase<MuDerived>& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, LambdaDerived, MuDerived >
LinearElasticityForm
Deduction guide for a function first parameter and a lifted shear modulus.
See declaration
template<class LambdaDerived, class M, class Solution, class FES>
LinearElasticityForm(const FunctionBase<LambdaDerived>& lambda, const M& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, LambdaDerived, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< M > > >::Type >
LinearElasticityForm
Deduction guide for a lifted first parameter and a function shear modulus.
See declaration
template<class L, class MuDerived, class Solution, class FES>
LinearElasticityForm(const L& lambda, const FunctionBase<MuDerived>& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type, MuDerived >
LinearElasticityForm
Deduction guide for two lifted Lamé parameters.
See declaration
template<class L, class M, class Solution, class FES>
LinearElasticityForm(const L& lambda, const M& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L > &&!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L > &&!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< M > > >::Type >
LinearElasticityIntegrator
Deduction guide for LinearElasticityIntegrator.
See declaration
template<class Solution, class FES, class LambdaDerived, class MuDerived>
LinearElasticityIntegrator(const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v, const FunctionBase<LambdaDerived>& lambda, const FunctionBase<MuDerived>& mu) -> LinearElasticityIntegrator< Solution, FES, LambdaDerived, MuDerived >
LinearElasticityIntegral
Deduction guide for LinearElasticityIntegral.
See declaration
template<class Solution, class FES>
LinearElasticityIntegral(const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityIntegral< Solution, FES >
template<class NestedDerived>
Abs(const FunctionBase<NestedDerived>& v) -> Abs< FunctionBase< NestedDerived > >
Deduction guide for Abs.
template<class NestedDerived>
auto abs(const FunctionBase<NestedDerived>& op) -> auto constexpr
Builds the pointwise absolute value of a function expression.
operator&&
Logical AND operator for boolean functions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator&&(const BooleanFunctionBase<LHSDerived>& lhs, const BooleanFunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class RHSDerived>
auto operator&&(Boolean lhs, const BooleanFunctionBase<RHSDerived>& rhs) -> auto constexpr
Logical AND with boolean constant on left.
template<class LHSDerived>
auto operator&&(const BooleanFunctionBase<LHSDerived>& lhs, Boolean rhs) -> auto constexpr
Logical AND with boolean constant on right.
template<class Derived>
Average(const FunctionBase<Derived>& op) -> Average< FunctionBase< Derived > >
Deduction guide for Average with FunctionBase.
Average
Deduction guide for Average with ShapeFunctionBase.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Average(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> Average< ShapeFunctionBase< NestedDerived, FES, Space > >
BilinearForm
Deduces the default sparse bilinear form type.
See declaration
template<class Solution, class TrialFES, class TestFES>
BilinearForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> BilinearForm< Solution, TrialFES, TestFES, Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType > ::Type > >
BooleanFunction(Boolean v) -> BooleanFunction< Boolean >
Deduction guide for BooleanFunction.
BoundaryIntegral
Deduction guide for BoundaryIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
BoundaryIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> BoundaryIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
BoundaryIntegral
Deduction guide for BoundaryIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
BoundaryIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> BoundaryIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
BoundaryIntegral
Deduction guide for BoundaryIntegral.
See declaration
template<class NestedDerived, class FES>
BoundaryIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> BoundaryIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >
BoundaryIntegral
Deduction guide for BoundaryIntegral.
See declaration
template<class LHSDerived, class RHSDerived, class FES>
BoundaryIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> BoundaryIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >
ComplexFunction(Integer x) -> ComplexFunction< Integer >
Deduction guide for integer constants.
ComplexFunction(Real x) -> ComplexFunction< Real >
Deduction guide for real constants.
ComplexFunction(const Complex& x) -> ComplexFunction< Complex >
CTAD for ComplexFunction.
ComplexFunction
CTAD for ComplexFunction.
See declaration
template<class Derived>
ComplexFunction(const FunctionBase<Derived>& nested) -> ComplexFunction< FunctionBase< Derived > >
ComplexFunction
CTAD for ComplexFunction.
See declaration
template<class RealNestedDerived, class ImagNestedDerived>
ComplexFunction(const FunctionBase<RealNestedDerived>& re, const FunctionBase<ImagNestedDerived>& imag) -> ComplexFunction< FunctionBase< RealNestedDerived >, FunctionBase< ImagNestedDerived > >
ComplexFunction
CTAD for ComplexFunction.
See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_r_v<Complex, F, const Geometry::Point&>>>
ComplexFunction(const F& f) -> ComplexFunction< F >
ComplexFunction
CTAD for ComplexFunction.
See declaration
template<class FReal, class FImag, typename = std::enable_if_t<std::is_invocable_v<FReal, const Geometry::Point&>&& std::is_invocable_v<FImag, const Geometry::Point&>>>
ComplexFunction(const FReal& re, const FImag& imag) -> ComplexFunction< FReal, FImag >
Component
Deduction guide for vector component extraction.
See declaration
template<class OperandDerived>
Component(const FunctionBase<OperandDerived>& fn, size_t index) -> Component< FunctionBase< OperandDerived >, size_t >
Component
Deduction guide for matrix entry extraction.
See declaration
template<class OperandDerived>
Component(const FunctionBase<OperandDerived>& u, size_t row, size_t column) -> Component< FunctionBase< OperandDerived >, size_t, size_t >
Component
Deduction guide for GridFunction component extraction.
See declaration
template<class FES, class Data>
Component(GridFunction<FES, Data>& fn, size_t index) -> Component< GridFunction< FES, Data > >
Component
Deduction guide for ShapeFunction component extraction.
See declaration
template<class OperandDerived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<OperandDerived, FES, Space>& fn, size_t index) -> Component< ShapeFunctionBase< OperandDerived, FES, Space > >
Component
Deduction guide for ShapeFunction component extraction.
See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<Derived, FES, Space>& u, size_t row, size_t column) -> Component< ShapeFunctionBase< Derived, FES, Space >, size_t, size_t >
Component
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Derived>
Component(const FunctionBase<Derived>& operand, size_t row, size_t column, size_t direction) -> Component< FunctionBase< Derived >, size_t, size_t, size_t >
Component
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<Derived, FES, Space>& operand, size_t row, size_t column, size_t direction) -> Component< ShapeFunctionBase< Derived, FES, Space >, size_t, size_t, size_t >
Conjugate
CTAD for Conjugate.
See declaration
template<class NestedDerived>
Conjugate(const FunctionBase<NestedDerived>& v) -> Conjugate< FunctionBase< NestedDerived > >
Conjugate
CTAD for Conjugate on shape functions.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Conjugate(const ShapeFunctionBase<NestedDerived, FES, Space>& v) -> Conjugate< ShapeFunctionBase< NestedDerived, FES, Space > >
template<class NestedDerived>
Cosh(const FunctionBase<NestedDerived>& v) -> Cosh< FunctionBase< NestedDerived > >
Deduction guide for Cosh.
template<class NestedDerived>
auto cosh(const FunctionBase<NestedDerived>& f) -> auto
Helper function to construct objects of type Cosh.
template<class NestedDerived>
Cos(const FunctionBase<NestedDerived>& v) -> Cos< FunctionBase< NestedDerived > >
Deduction guide for Cos.
template<class NestedDerived>
auto cos(const FunctionBase<NestedDerived>& f) -> auto
Helper function to construct objects of type Cos.
DenseProblem
Deduction guide for DenseProblem.
See declaration
template<class U, class V>
DenseProblem(U& u, V& v) -> DenseProblem< Math::LinearSystem< Math::Matrix< typename FormLanguage::Traits< typename FormLanguage::Traits< U >::FESType > ::ScalarType >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType > ::ScalarType > >, U, V >
Derivative
Deduction guide for Derivative.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType SpaceType>
Derivative(size_t i, const ShapeFunction<NestedDerived, FES, SpaceType>& u) -> Derivative< ShapeFunction< NestedDerived, FES, SpaceType > >
template<class Operand>
auto Dx(const Operand& u) -> auto
Utility function for computing $ \partial_x u $
template<class Operand>
auto Dy(const Operand& u) -> auto
Utility function for computing $ \partial_y u $
template<class Operand>
auto Dz(const Operand& u) -> auto
Utility function for computing $ \partial_z u $
Derivative
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class FES, class Data>
Derivative(size_t direction, const GridFunction<FES, Data>& operand) -> Derivative< GridFunction< FES, Data > >
Derivative
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Derivative(size_t direction, const ShapeFunction<Derived, FES, Space>& operand) -> Derivative< ShapeFunction< Derived, FES, Space > >
DiffusionForm
Deduction guide for the unweighted diffusion form.
See declaration
template<class Solution, class TrialFES, class TestFES>
DiffusionForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type >
DiffusionForm
Deduction guide for the diffusion form weighted by a function.
See declaration
template<class CoefficientDerived, class Solution, class TrialFES, class TestFES>
DiffusionForm(const FunctionBase<CoefficientDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, CoefficientDerived >
DiffusionForm
Deduction guide for the diffusion form weighted by a lifted value.
See declaration
template<class L, class Solution, class TrialFES, class TestFES>
DiffusionForm(const L& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type >
DirichletBC
CTAD for DirichletBC.
See declaration
template<class Solution, class FES, class FunctionDerived>
DirichletBC(const TrialFunction<Solution, FES>& u, const FunctionBase<FunctionDerived>& v) -> DirichletBC< TrialFunction< Solution, FES >, FunctionBase< FunctionDerived > >
DirichletBC
CTAD for the identification DirichletBC.
See declaration
template<class Solution, class FES1, class Derived2, class FES2, ShapeFunctionSpaceType Sp>
DirichletBC(const TrialFunction<Solution, FES1>& u, const ShapeFunctionBase<Derived2, FES2, Sp>& v) -> DirichletBC< TrialFunction< Solution, FES1 >, ShapeFunctionBase< Derived2, FES2, Sp > >
DirichletBC
Deduction guide for DirichletBC.
See declaration
template<class Solution, class FES1, class Derived2, class FES2, ShapeFunctionSpaceType Sp, class DefectDerived>
DirichletBC(const TrialFunction<Solution, FES1>& u, const ShapeFunctionBase<Derived2, FES2, Sp>& value, const FunctionBase<DefectDerived>& defect) -> DirichletBC< TrialFunction< Solution, FES1 >, ShapeFunctionBase< Derived2, FES2, Sp > >
template<class FES, class Data>
Div(const GridFunction<FES, Data>& operand) -> Div< GridFunction< FES, Data > >
Deduces the matrix space or coefficient type from constructor arguments.
Div
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<Derived, FES, Space>& operand) -> Div< ShapeFunction< Derived, FES, Space > >
Division
Deduction guide for Division.
See declaration
template<class LHSDerived, class RHSDerived>
Division(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Division< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
operator/
Division operator for two functions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator/(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto
operator/
Division of a function by a number.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>, Division<LHSDerived, RealFunction<Number>>>>
auto operator/(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto
operator/
Division of a number by a function.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>, Division<RHSDerived, RealFunction<Number>>>>
auto operator/(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto
Division
Deduction guide for Division.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Division(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Division< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >
operator/
Quotient of two shape function expressions.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator/(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto
Dot
Deduction guide for Dot product of two functions.
See declaration
template<class LHSDerived, class RHSDerived>
Dot(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Dot< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Dot
Deduction guide for Dot product of function and shape function.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Dot(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, Space > >
Dot
Deduction guide for Dot product of shape function and function.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Dot(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Dot< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >
Dot
Deduction guide for Dot product of trial and test shape functions.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Dot(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >
Dot
Deduction guide for Dot product of potential and test shape function.
See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Dot(const Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >
operator==
Equality comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator==(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class RHSDerived>
auto operator==(Boolean lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Equality comparison of two function expressions.
template<class LHSDerived>
auto operator==(const FunctionBase<LHSDerived>& lhs, Boolean rhs) -> auto constexpr
Equality comparison of two function expressions.
operator==
Equality comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator==(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator==
Equality comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator==(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
UndeterminedTraceDomainException
Deduction guide for UndeterminedTraceDomainException.
See declaration
template<class T, class FuncName, class Iterator>
UndeterminedTraceDomainException(const T& cls, const FuncName& funcName, const std::pair<size_t, Index>& p, Iterator begin, Iterator end) -> UndeterminedTraceDomainException< T, FuncName >
template<class NestedDerived>
Exp(const FunctionBase<NestedDerived>& v) -> Exp< FunctionBase< NestedDerived > >
Deduction guide for Exp.
template<class NestedDerived>
auto exp(const FunctionBase<NestedDerived>& op) -> auto constexpr
Builds the pointwise exponential of a function expression.
FaceIntegral
Deduction guide for FaceIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
FaceIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& prod) -> FaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
FaceIntegral
Deduction guide for FaceIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
FaceIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> FaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
FaceIntegral
Deduction guide for FaceIntegral.
See declaration
template<class NestedDerived, class FES>
FaceIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& prod) -> FaceIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >
FaceIntegral
Deduction guide for FaceIntegral.
See declaration
template<class LHSDerived, class RHSDerived, class FES>
FaceIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> FaceIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >
Flow
Deduction guide for Flow.
See declaration
template<class Derived, class Velocity>
Flow(const Real& time, const FunctionBase<Derived>& operand, Velocity&& velocity) -> Flow< FunctionBase< Derived >, Velocity, Math::RungeKutta::RK4, DefaultBoundaryPolicy >
Flow
Deduction guide for Flow.
See declaration
template<class Derived, class Velocity, class Step>
Flow(const Real& time, const FunctionBase<Derived>& operand, Velocity&& velocity, Step&& stepper) -> Flow< FunctionBase< Derived >, Velocity, Step, DefaultBoundaryPolicy >
Flow
Deduction guide for Flow.
See declaration
template<class Derived, class Velocity, class Step, class BBP>
Flow(const Real& t, const FunctionBase<Derived>& u, Velocity&& vel, Step&& st, BBP&& bp) -> Flow< FunctionBase< Derived >, Velocity, Step, BBP >
Frobenius
Deduction guide for Frobenius norm.
See declaration
template<class NestedDerived>
Frobenius(const FunctionBase<NestedDerived>& v) -> Frobenius< FunctionBase< NestedDerived > >
GetOrderIfConstant
Returns the order only when a function is elementwise constant.
See declaration
template<class Derived>
auto GetOrderIfConstant(const FunctionBase<Derived>& f, const Geometry::Polytope& polytope) -> Optional<size_t> noexcept
operator>=
Greater-or-equal comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator>=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator>=
Greater-or-equal comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>=(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator>=
Greater-or-equal comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>=(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
template<class FES, class Data>
Grad(const GridFunction<FES, Data>& operand) -> Grad< GridFunction< FES, Data > >
CTAD for Grad of a GridFunction.
Grad
CTAD for Grad of a ShapeFunction.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Grad(const ShapeFunction<NestedDerived, FES, Space>& operand) -> Grad< ShapeFunction< NestedDerived, FES, Space > >
GridFunction
Deduces the default dense-vector grid function type.
See declaration
template<class FES>
GridFunction(const FES& fes) -> GridFunction< FES, Math::Vector< typename FormLanguage::Traits< FES >::ScalarType > >
template<class FES, class Data>
GridFunction(const FES& fes, Data&& data) -> GridFunction< FES, Data >
Deduces a grid function type from a finite element space and data object.
operator>
Greater-than comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator>(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator>
Greater-than comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator>
Greater-than comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
Derivative
CTAD for Derivative of an H1 GridFunction.
See declaration
template<size_t K, class Scalar, class Data, class Mesh>
Derivative(size_t i, const GridFunction<H1<K, Scalar, Mesh>, Data>& u) -> Derivative< GridFunction< H1< K, Scalar, Mesh >, Data > >
Div
CTAD for Div of an H1 GridFunction.
See declaration
template<size_t K, class Scalar, class Data, class Mesh>
Div(const GridFunction<H1<K, Math::SpatialVector<Scalar>, Mesh>, Data>& u) -> Div< GridFunction< H1< K, Math::SpatialVector< Scalar >, Mesh >, Data > >
Div
Deduction guide for Div.
See declaration
template<size_t K, class NestedDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, H1< K, Math::SpatialVector< Number >, Mesh >, Space > >
H1
CTAD for H1 from mesh - deduces to RealH1.
See declaration
template<size_t K, class Context>
H1(std::integral_constant<size_t, K> order, const Geometry::Mesh<Context>& mesh) -> H1< K, Real, Geometry::Mesh< Context > >
H1
CTAD for Vector H1 from mesh and vector dimension.
See declaration
template<size_t K, class Context>
H1(std::integral_constant<size_t, K> order, const Geometry::Mesh<Context>& mesh, size_t vdim) -> H1< K, Math::SpatialVector< Real >, Geometry::Mesh< Context > >
H1
Deduces a matrix range from explicit rows and columns.
See declaration
template<size_t K, class Context>
H1(std::integral_constant<size_t, K> orderTag, const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> H1< K, Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >
Jacobian
CTAD for Jacobian of an H1 GridFunction.
See declaration
template<size_t K, class Range, class Data, class Mesh>
Jacobian(const GridFunction<H1<K, Range, Mesh>, Data>& u) -> Jacobian< GridFunction< H1< K, Range, Mesh >, Data > >
Jacobian
Deduction guide for Jacobian.
See declaration
template<size_t K, class ShapeFunctionDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, H1< K, Math::SpatialVector< Number >, Mesh >, Space > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t K, class NestedDerived, class Scalar, class Mesh>
QuadratureRule(const ShapeFunctionBase<ShapeFunction<NestedDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>& integrand) -> QuadratureRule< ShapeFunctionBase< ShapeFunction< NestedDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t K, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>>, H1<K, Scalar, Mesh>, TestSpace>& integrand) -> QuadratureRule< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace > >, H1< K, Scalar, Mesh >, TestSpace > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class TrialRange, class TestRange, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>, H1<KTest, TestRange, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Div< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace > >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace >, H1< KTest, TestRange, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class TrialRange, class TestRange, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>>, H1<KTest, TestRange, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< Div< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace > >, H1< KTest, TestRange, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, FunctionBase<CoefficientDerived>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, FunctionBase< CoefficientDerived > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >
HelmholtzForm
Deduction guide for two function coefficients.
See declaration
template<class DiffusionDerived, class MassDerived, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const FunctionBase<DiffusionDerived>& a, const FunctionBase<MassDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, DiffusionDerived, MassDerived >
HelmholtzForm
Deduction guide for a function diffusion and a lifted mass coefficient.
See declaration
template<class DiffusionDerived, class C, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const FunctionBase<DiffusionDerived>& a, const C& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, DiffusionDerived, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< C > > >::Type >
HelmholtzForm
Deduction guide for a lifted diffusion and a function mass coefficient.
See declaration
template<class A, class MassDerived, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const A& a, const FunctionBase<MassDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A >, FormLanguage::FunctionDerived< RealFunction< A > > >::Type, MassDerived >
HelmholtzForm
Deduction guide for two lifted coefficients.
See declaration
template<class A, class C, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const A& a, const C& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A > &&!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< A > > >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A > &&!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< C > > >::Type >
template<class NestedDerived>
Im(const FunctionBase<NestedDerived>& f) -> Im< FunctionBase< NestedDerived > >
CTAD for Im.
Integral
Deduction guide for Integral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> Integral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
Integral
Deduction guide for Integral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Integral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
Integral
Deduction guide for Integral.
See declaration
template<class NestedDerived, class FES>
Integral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> Integral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >
Integral
Deduction guide for Integral.
See declaration
template<class LHSDerived, class RHSDerived, class FES>
Integral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> Integral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > > > >
Integral
Deduction guide for Integral.
See declaration
template<class FES, class Data>
Integral(const GridFunction<FES, Data>& integrand) -> Integral< GridFunction< FES, Data > >
InterfaceIntegral
Deduction guide for InterfaceIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
InterfaceIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> InterfaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
InterfaceIntegral
Deduction guide for InterfaceIntegral.
See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
InterfaceIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> InterfaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
InterfaceIntegral
Deduction guide for InterfaceIntegral.
See declaration
template<class NestedDerived, class FES>
InterfaceIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> InterfaceIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >
InterfaceIntegral
Deduction guide for InterfaceIntegral.
See declaration
template<class LHSDerived, class RHSDerived, class FES>
InterfaceIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> InterfaceIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >
Jacobian
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class FES, class Data>
Jacobian(const GridFunction<FES, Data>& operand) -> Jacobian< GridFunction< FES, Data > >
Jacobian
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<Derived, FES, Space>& operand) -> Jacobian< ShapeFunction< Derived, FES, Space > >
template<class Derived>
Jump(const FunctionBase<Derived>& op) -> Jump< FunctionBase< Derived > >
Deduction guide for Jump with FunctionBase.
Jump
Deduction guide for Jump with ShapeFunctionBase.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Jump(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> Jump< ShapeFunctionBase< NestedDerived, FES, Space > >
operator<=
Less-or-equal comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator<=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator<=
Less-or-equal comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<=(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator<=
Less-or-equal comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<=(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
LinearForm
CTAD for LinearForm.
See declaration
template<class FES>
LinearForm(const TestFunction<FES>& v) -> LinearForm< FES, Math::Vector< typename FormLanguage::Traits< FES >::ScalarType > >
operator<
Less-than comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator<(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator<
Less-than comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator<
Less-than comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
MassForm
Deduction guide for the unweighted mass form.
See declaration
template<class Solution, class TrialFES, class TestFES>
MassForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type >
MassForm
Deduction guide for the mass form weighted by a function.
See declaration
template<class CoefficientDerived, class Solution, class TrialFES, class TestFES>
MassForm(const FunctionBase<CoefficientDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, CoefficientDerived >
MassForm
Deduction guide for the mass form weighted by a lifted value.
See declaration
template<class L, class Solution, class TrialFES, class TestFES>
MassForm(const L& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type >
template<class Scalar>
MatrixFunction(const Math::Matrix<Scalar>& matrix) -> MatrixFunction< Math::Matrix< Scalar > >
Deduction guide for MatrixFunction.
MatrixFunction
Deduces a dense matrix coefficient from native Eigen storage.
See declaration
template<class Scalar>
MatrixFunction(const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>& matrix) -> MatrixFunction< Math::Matrix< Scalar > >
MatrixFunction
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Scalar>
MatrixFunction(const Math::SpatialMatrix<Scalar>& matrix) -> MatrixFunction< Math::SpatialMatrix< Scalar > >
template<class F>
MatrixFunction(size_t rows, size_t columns, F function) -> MatrixFunction< F >
Deduces the matrix space or coefficient type from constructor arguments.
Max
Deduction guide for Max.
See declaration
template<class LHSDerived, class RHSDerived>
Max(const FunctionBase<LHSDerived>& a, const FunctionBase<RHSDerived>& b) -> Max< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Max
Deduction guide for Max.
See declaration
template<class NestedDerived>
Max(const FunctionBase<NestedDerived>& a, Real b) -> Max< FunctionBase< NestedDerived >, Real >
Max
Deduction guide for Max.
See declaration
template<class NestedDerived>
Max(Real a, const FunctionBase<NestedDerived>& b) -> Max< Real, FunctionBase< NestedDerived > >
Min
Deduction guide for Min.
See declaration
template<class LHSDerived, class RHSDerived>
Min(const FunctionBase<LHSDerived>& a, const FunctionBase<RHSDerived>& b) -> Min< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Min
Deduction guide for Min.
See declaration
template<class NestedDerived>
Min(const FunctionBase<NestedDerived>& a, Real b) -> Min< FunctionBase< NestedDerived >, Real >
Min
Deduction guide for Min.
See declaration
template<class NestedDerived>
Min(Real a, const FunctionBase<NestedDerived>& b) -> Min< Real, FunctionBase< NestedDerived > >
operator-
Subtracts a number from a function.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator-(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
operator-
Subtracts a function from a number.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator-(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator-
Subtracts two functions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator-(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator-
Subtracts two shape functions.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator-(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> auto constexpr
operator-
Subtracts two bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator-(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
operator-
Subtracts a list of bilinear form integrators from a single integrator.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator-(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
operator-
Subtracts a single bilinear form integrator from a list.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
operator-
Subtracts two lists of bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
Mult
Deduction guide for Mult of two FunctionBase instances.
See declaration
template<class LHSDerived, class RHSDerived>
Mult(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Mult< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
operator*
Multiplies two functions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class RHSDerived>
auto operator*(Real lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Multiplies a real number by a function (scalar multiplication).
template<class RHSDerived>
auto operator*(Complex lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Multiplies a complex number by a function (scalar multiplication).
template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, Real rhs) -> auto constexpr
Multiplies a function by a real number (scalar multiplication).
template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, Complex rhs) -> auto constexpr
Multiplies a function by a complex number (scalar multiplication).
template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, const Math::Matrix<Real>& rhs) -> auto
Product of two function expressions.
template<class LHSDerived>
auto operator*(const Math::Matrix<Real>& lhs, const FunctionBase<LHSDerived>& rhs) -> auto
Product of two function expressions.
Mult
Deduction guide for Mult.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Mult(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Mult< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, Space > >
operator*
Product of two shape function expressions.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const Real& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const Complex& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> auto constexpr
Mult
Deduction guide for Mult.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Mult(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Mult< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >
operator*
Product of two shape function expressions.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class LHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const Real& rhs) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class LHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const Complex& rhs) -> auto constexpr
Mult
Deduction guide for Mult.
See declaration
template<class Number, class RHSScalar>
Mult(const Number& lhs, const LocalBilinearFormIntegratorBase<RHSScalar>& rhs) -> Mult< Number, LocalBilinearFormIntegratorBase< RHSScalar > >
operator*
Product of two bilinear form integrators.
See declaration
template<class Number, class RHSScalar>
auto operator*(const Number& lhs, const LocalBilinearFormIntegratorBase<RHSScalar>& rhs) -> auto constexpr
Mult
Deduction guide for Mult.
See declaration
template<class Number, class RHSScalar>
Mult(const Number& lhs, const LinearFormIntegratorBase<RHSScalar>& rhs) -> Mult< Number, LinearFormIntegratorBase< RHSScalar > >
operator*
Product of two linear form integrators.
See declaration
template<class Number, class RHSScalar>
auto operator*(const Number& lhs, const LinearFormIntegratorBase<RHSScalar>& rhs) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class CoeffDerived, class TrialDerived, class TrialFES, class TestDerived, class TestFES>
auto operator*(const FunctionBase<CoeffDerived>& coeff, const Dot<ShapeFunctionBase<TrialDerived, TrialFES, TrialSpace>, ShapeFunctionBase<TestDerived, TestFES, TestSpace>>& dot) -> auto constexpr
operator*
Product of two shape function expressions.
See declaration
template<class TrialDerived, class TrialFES, class TestDerived, class TestFES, class CoeffDerived>
auto operator*(const Dot<ShapeFunctionBase<TrialDerived, TrialFES, TrialSpace>, ShapeFunctionBase<TestDerived, TestFES, TestSpace>>& dot, const FunctionBase<CoeffDerived>& coeff) -> auto constexpr
operator!=
Inequality comparison of two function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator!=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class RHSDerived>
auto operator!=(Boolean lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Inequality comparison of two function expressions.
template<class LHSDerived>
auto operator!=(const FunctionBase<LHSDerived>& lhs, Boolean rhs) -> auto constexpr
Inequality comparison of two function expressions.
operator!=
Inequality comparison of two function expressions.
See declaration
template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator!=(Number lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
operator!=
Inequality comparison of two function expressions.
See declaration
template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator!=(const FunctionBase<LHSDerived>& lhs, Number rhs) -> auto constexpr
operator||
Logical disjunction of two boolean function expressions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator||(const BooleanFunctionBase<LHSDerived>& lhs, const BooleanFunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class RHSDerived>
auto operator||(Boolean lhs, const BooleanFunctionBase<RHSDerived>& rhs) -> auto constexpr
Logical disjunction of two boolean function expressions.
template<class LHSDerived>
auto operator||(const BooleanFunctionBase<LHSDerived>& lhs, Boolean rhs) -> auto constexpr
Logical disjunction of two boolean function expressions.
Grad
CTAD for Grad of a P0 GridFunction.
See declaration
template<class Range, class Data, class Mesh>
Grad(const GridFunction<P0<Range, Mesh>, Data>& operand) -> Grad< GridFunction< P0< Range, Mesh >, Data > >
Grad
Deduction guide for Grad.
See declaration
template<class NestedDerived, class Range, class Mesh, ShapeFunctionSpaceType Space>
Grad(const ShapeFunction<NestedDerived, P0<Range, Mesh>, Space>& operand) -> Grad< ShapeFunction< NestedDerived, P0< Range, Mesh >, Space > >
template<class Context>
P0(const Geometry::Mesh<Context>& mesh) -> P0< Real, Geometry::Mesh< Context > >
CTAD for P0 from mesh - deduces to RealP0.
P0
Deduces a matrix range from explicit rows and columns.
See declaration
template<class Context>
P0(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P0< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >
Div
CTAD for Div of a P0g GridFunction.
See declaration
template<class Scalar, class Data, class Mesh>
Div(const GridFunction<P0g<Math::SpatialVector<Scalar>, Mesh>, Data>& u) -> Div< GridFunction< P0g< Math::SpatialVector< Scalar >, Mesh >, Data > >
Div
Deduction guide for Div.
See declaration
template<class NestedDerived, class Scalar, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space > >
Jacobian
CTAD for Jacobian of a P0g vector GridFunction.
See declaration
template<class Range, class Data, class Mesh>
Jacobian(const GridFunction<P0g<Range, Mesh>, Data>& u) -> Jacobian< GridFunction< P0g< Range, Mesh >, Data > >
Jacobian
Deduction guide for Jacobian.
See declaration
template<class ShapeFunctionDerived, class Scalar, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space > >
template<class Context>
P0g(const Geometry::Mesh<Context>& mesh) -> P0g< Real, Geometry::Mesh< Context > >
Deduction guide for P0g.
P0g
Deduces the matrix space or coefficient type from constructor arguments.
See declaration
template<class Context>
P0g(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P0g< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >
Derivative
CTAD for Derivative of a P1 GridFunction.
See declaration
template<class Range, class Data, class Mesh>
Derivative(size_t i, const GridFunction<P1<Range, Mesh>, Data>& u) -> Derivative< GridFunction< P1< Range, Mesh >, Data > >
Div
CTAD for Div of a P1 GridFunction.
See declaration
template<class Scalar, class Data, class Mesh>
Div(const GridFunction<P1<Math::SpatialVector<Scalar>, Mesh>, Data>& u) -> Div< GridFunction< P1< Math::SpatialVector< Scalar >, Mesh >, Data > >
Div
Deduction guide for Div.
See declaration
template<class NestedDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, P1<Math::SpatialVector<Number>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, P1< Math::SpatialVector< Number >, Mesh >, Space > >
Jacobian
CTAD for Jacobian of a P1 GridFunction.
See declaration
template<class Range, class Data, class Mesh>
Jacobian(const GridFunction<P1<Range, Mesh>, Data>& u) -> Jacobian< GridFunction< P1< Range, Mesh >, Data > >
Jacobian
Deduction guide for Jacobian.
See declaration
template<class ShapeFunctionDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, P1<Math::SpatialVector<Number>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, P1< Math::SpatialVector< Number >, Mesh >, Space > >
template<class Context>
P1(const Geometry::Mesh<Context>& mesh) -> P1< Real, Geometry::Mesh< Context > >
CTAD for P1 from mesh - deduces to RealP1.
P1
CTAD for Vector P1 from mesh and vector dimension.
See declaration
template<class Context>
P1(const Geometry::Mesh<Context>& mesh, size_t vdim) -> P1< Math::SpatialVector< Real >, Geometry::Mesh< Context > >
P1
Deduces a matrix range from explicit rows and columns.
See declaration
template<class Context>
P1(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P1< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class NestedDerived, class Range, class Mesh>
QuadratureRule(const ShapeFunctionBase<ShapeFunction<NestedDerived, P1<Range, Mesh>, TestSpace>>& integrand) -> QuadratureRule< ShapeFunctionBase< ShapeFunction< NestedDerived, P1< Range, Mesh >, TestSpace > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class CoefficientDerived, class LHSDerived, class RHSDerived, class Number, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Number, Mesh>, TrialSpace>>>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Number, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Number, Mesh >, TrialSpace > > > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Number, Mesh >, TestSpace > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > > >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSFunctionDerived, class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<LHSFunctionDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>>>>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< LHSFunctionDerived >, ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > > > > >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class CoefficientDerived, class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
QuadratureRule(const P1DivTrialIntegrand<LHSDerived, RHSDerived, LHSMesh, RHSMesh>& integrand) -> QuadratureRule< P1DivTrialIntegrand< LHSDerived, RHSDerived, LHSMesh, RHSMesh > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
QuadratureRule(const P1DivTestIntegrand<LHSDerived, RHSDerived, LHSMesh, RHSMesh>& integrand) -> QuadratureRule< P1DivTestIntegrand< LHSDerived, RHSDerived, LHSMesh, RHSMesh > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > > >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class LHSFunctionDerived, class LHSDerived, class RHSDerived, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<LHSFunctionDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<Math::SpatialVector<Real>, Mesh>, TrialSpace>>>>>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, P1<Math::SpatialVector<Real>, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< LHSFunctionDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, P1< Math::SpatialVector< Real >, Mesh >, TrialSpace > > > > >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, P1< Math::SpatialVector< Real >, Mesh >, TestSpace > > > > >
QuadratureRule
Deduction guide for QuadratureRule.
See declaration
template<class CoefficientDerived, class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>, P1<Range, Mesh>, TrialSpace>, FunctionBase<CoefficientDerived>>, P1<Range, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>, P1<Range, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > >, P1< Range, Mesh >, TrialSpace >, FunctionBase< CoefficientDerived > >, P1< Range, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace >, P1< Range, Mesh >, TestSpace > > >
PeriodicBC
CTAD for PeriodicBC.
See declaration
template<class Solution, class FES>
PeriodicBC(const TrialFunction<Solution, FES>& u, const IndexMap<IndexSet>& adjacency) -> PeriodicBC< TrialFunction< Solution, FES >, IndexMap< IndexSet > >
Potential
CTAD for Potential.
See declaration
template<class LHSType, class RHSDerived>
Potential(const LHSType& kernel, const FunctionBase<RHSDerived>& u) -> Potential< LHSType, FunctionBase< RHSDerived > >
Potential
CTAD for Potential.
See declaration
template<class LHSType, class RHSDerived, class FESType, ShapeFunctionSpaceType SpaceType>
Potential(const LHSType& kernel, const ShapeFunctionBase<ShapeFunction<RHSDerived, FESType, SpaceType>, FESType, SpaceType>& u) -> Potential< LHSType, ShapeFunctionBase< ShapeFunction< RHSDerived, FESType, SpaceType >, FESType, SpaceType > >
Integral
Deduction guide for Integral.
See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Dot<Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> Integral< Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
Integral
Deduction guide for Integral.
See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Integral< Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >
Pow
Deduction guide for Pow.
See declaration
template<class BaseDerived, class Number>
Pow(const FunctionBase<BaseDerived>& base, Number exponent) -> Pow< FunctionBase< BaseDerived >, Number >
template<class NestedDerived, class Number>
auto pow(const FunctionBase<NestedDerived>& f, Number exponent) -> auto
Builds the pointwise power of a function expression.
Problem
Deduction guide for a two-field sparse variational problem.
See declaration
template<class U, class V>
Problem(U& u, V& v) -> Problem< Math::LinearSystem< Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< typename FormLanguage::Traits< U >::FESType >::ScalarType, typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType >::ScalarType >::Type >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType >::ScalarType > >, U, V >
Problem
Deduction guide for Problem.
See declaration
template<class U1, class U2, class U3, class... Us>
Problem(U1& u1, U2& u2, U3& u3, Us&... us) -> Problem< Math::LinearSystem< Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< typename FormLanguage::Traits< U1 >::FESType >::ScalarType, typename FormLanguage::Traits< typename FormLanguage::Traits< U2 >::FESType >::ScalarType >::Type >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< U2 >::FESType >::ScalarType > >, U1, U2, U3, Us... >
ProblemBody
Deduction guide for ProblemBody.
See declaration
template<class Scalar>
ProblemBody(const LocalBilinearFormIntegratorBase<Scalar>& pbo) -> ProblemBody< void, void, Scalar >
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LinearFormIntegratorBase<LHSScalar>& lfi, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const GlobalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const GlobalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const LinearFormIntegratorBase<LHSScalar>& lfi, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const FormLanguage::List<GlobalBilinearFormIntegratorBase<RHSScalar>>& gbfis) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& lbfi, const FormLanguage::List<GlobalBilinearFormIntegratorBase<RHSScalar>>& gbfis) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& lbfi, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const DirichletBCBase<RHSScalar>& dbc) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const PeriodicBCBase<RHSScalar>& pbc) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const DirichletBCBase<RHSScalar>& dbc) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LocalBilinearFormIntegratorBase<RHSScalar>& lbfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LocalBilinearFormIntegratorBase<RHSScalar>& lbfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const DirichletBCBase<RHSScalar>& dbc) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const PeriodicBCBase<RHSScalar>& pbc) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const BilinearFormBase<OperatorType>& bf) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class OperatorType, class LHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const BilinearFormBase<OperatorType>& bf) -> auto
operator+
Combines a bilinear form and a local bilinear form integrator.
See declaration
template<class OperatorType, class RHSScalar>
auto operator+(const BilinearFormBase<OperatorType>& bf, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi) -> auto
operator+
Combines a preassembled BilinearForm with a DirichletBC into a ProblemBody.
See declaration
template<class OperatorType, class RHSScalar>
auto operator+(const BilinearFormBase<OperatorType>& bf, const DirichletBCBase<RHSScalar>& dbc) -> auto
operator-
Subtracts a linear integrator from a preassembled bilinear form.
See declaration
template<class OperatorType, class RHSScalar>
auto operator-(const BilinearFormBase<OperatorType>& bf, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator-
Subtracts a linear integrator from preassembled bilinear forms.
See declaration
template<class OperatorType, class RHSScalar>
auto operator-(const FormLanguage::List<BilinearFormBase<OperatorType>>& bfs, const LinearFormIntegratorBase<RHSScalar>& lfi) -> auto
operator+
Combines a local bilinear integrator with preassembled bilinear forms.
See declaration
template<class LHSScalar, class OperatorType>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<BilinearFormBase<OperatorType>>& bfs) -> auto
operator+
Combines a list of local bilinear form integrators with a preassembled BilinearForm into a ProblemBody.
See declaration
template<class LHSScalar, class OperatorType>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const BilinearFormBase<OperatorType>& bf) -> auto
operator-
Subtracts a preassembled LinearForm from a single local bilinear form integrator to create a ProblemBody.
See declaration
template<class LHSScalar, class VectorType>
auto operator-(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormBase<VectorType>& lf) -> auto
operator-
Subtracts a preassembled LinearForm from a list of local bilinear form integrators to create a ProblemBody.
See declaration
template<class LHSScalar, class VectorType>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const LinearFormBase<VectorType>& lf) -> auto
operator-
Subtracts a preassembled LinearForm from a ProblemBody that has an OperatorType but no VectorType yet.
See declaration
template<class OperatorType, class LHSScalar, class VectorType>
auto operator-(const ProblemBody<OperatorType, void, LHSScalar>& pb, const LinearFormBase<VectorType>& lf) -> auto
operator-
Subtracts a preassembled LinearForm from a ProblemBody that already carries a VectorType.
See declaration
template<class OperatorType, class VectorType, class LHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const LinearFormBase<VectorType>& lf) -> auto
operator-
Subtracts an owned snapshot of a preassembled bilinear form.
See declaration
template<class Operator, class Vector, class Scalar>
auto operator-(const ProblemBody<Operator, Vector, Scalar>& pb, const BilinearFormBase<Operator>& bf) -> auto
operator+
Adds a preassembled linear form to the residual, hence negates its load.
See declaration
template<class Operator, class Vector, class Scalar>
auto operator+(const ProblemBody<Operator, Vector, Scalar>& pb, const LinearFormBase<Vector>& lf) -> auto
operator+
Combines linear integrators with a local bilinear integrator.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSScalar>>& lfis, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class LHSScalar, class RHSScalar>
auto operator-(const FormLanguage::List<LinearFormIntegratorBase<LHSScalar>>& lfis, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi) -> auto
operator+
Adds variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSScalar>>& bfis) -> auto
operator-
Subtracts variational terms to construct a problem body.
See declaration
template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<Operator, Vector, LHSScalar>& pb, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSScalar>>& bfis) -> auto
template<class NestedDerived>
Re(const FunctionBase<NestedDerived>& f) -> Re< FunctionBase< NestedDerived > >
CTAD for Re.
template<class Derived>
RealFunction(const FunctionBase<Derived>& nested) -> RealFunction< FunctionBase< Derived > >
CTAD for RealFunction.
RealFunction
CTAD for a typed real-function base.
See declaration
template<class Derived>
RealFunction(const RealFunctionBase<Derived>& nested) -> RealFunction< FunctionBase< typename RealFunctionBase< Derived >::Parent > >
RealFunction(Real x) -> RealFunction< Real >
CTAD for RealFunction.
RealFunction(Integer x) -> RealFunction< Integer >
CTAD for integer constants.
RealFunction
CTAD for RealFunction.
See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_v<F, const Geometry::Point&>>>
RealFunction(F f) -> RealFunction< F >
template<class NestedDerived>
Sin(const FunctionBase<NestedDerived>& v) -> Sin< FunctionBase< NestedDerived > >
Deduction guide for Sin.
template<class NestedDerived>
auto sin(const FunctionBase<NestedDerived>& f) -> auto
Helper function to construct objects of type Sin.
template<class NestedDerived>
Sinh(const FunctionBase<NestedDerived>& v) -> Sinh< FunctionBase< NestedDerived > >
Deduction guide for Sinh.
template<class NestedDerived>
auto sinh(const FunctionBase<NestedDerived>& f) -> auto
Helper function to construct objects of type Sinh.
SparseProblem
Deduction guide for SparseProblem.
See declaration
template<class U, class V>
SparseProblem(U& u, V& v) -> SparseProblem< Math::LinearSystem< Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< typename FormLanguage::Traits< U >::FESType >::ScalarType, typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType >::ScalarType >::Type >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType >::ScalarType > >, U, V >
template<class NestedDerived>
Sqrt(const FunctionBase<NestedDerived>& v) -> Sqrt< FunctionBase< NestedDerived > >
Deduction guide for Sqrt.
template<class NestedDerived>
auto sqrt(const FunctionBase<NestedDerived>& f) -> auto
Helper function to construct objects of type Sqrt.
Sum
Deduction guide for function sum.
See declaration
template<class LHSDerived, class RHSDerived>
Sum(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Sum< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Sum
Deduction guide for Sum.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Sum(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Sum< ShapeFunctionBase< LHSDerived, FES, Space >, ShapeFunctionBase< RHSDerived, FES, Space > >
operator+
Sum of two shape function expressions.
See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator+(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LinearFormIntegratorBase<LHSNumber>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< LinearFormIntegratorBase< LHSNumber >, LinearFormIntegratorBase< RHSNumber > >
operator+
Sum of two linear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const LinearFormIntegratorBase<LHSNumber>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< LinearFormIntegratorBase< LHSNumber >, FormLanguage::List< LinearFormIntegratorBase< RHSNumber > > >
operator+
Sum of two linear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const LinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >, LinearFormIntegratorBase< RHSNumber > >
operator+
Sum of two linear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >, FormLanguage::List< LinearFormIntegratorBase< RHSNumber > > >
operator+
Sum of two linear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< LocalBilinearFormIntegratorBase< LHSNumber >, LocalBilinearFormIntegratorBase< RHSNumber > >
operator+
Sum of two bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< LocalBilinearFormIntegratorBase< LHSNumber >, FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > > >
operator+
Sum of two bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >, LocalBilinearFormIntegratorBase< RHSNumber > >
operator+
Sum of two bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >, FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > > >
operator+
Sum of two bilinear form integrators.
See declaration
template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> auto constexpr
Sum
Deduction guide for Sum.
See declaration
template<class Operator>
Sum(const BilinearFormBase<Operator>& lhs, const BilinearFormBase<Operator>& rhs) -> Sum< BilinearFormBase< Operator >, BilinearFormBase< Operator > >
operator+
Sum of two expressions.
See declaration
template<class Operator>
auto operator+(const BilinearFormBase<Operator>& lhs, const BilinearFormBase<Operator>& rhs) -> auto constexpr
template<class NestedDerived>
Tan(const FunctionBase<NestedDerived>& v) -> Tan< FunctionBase< NestedDerived > >
Deduction guide for Tan.
template<class NestedDerived>
auto tan(const FunctionBase<NestedDerived>& f) -> auto
Builds the pointwise tangent of a function expression.
template<class Value>
TensorFunction(Value value) -> TensorFunction< Value >
Deduces the matrix space or coefficient type from constructor arguments.
template<class FES>
TestFunction(const FES& fes) -> TestFunction< FES >
Deduction guide for TestFunction.
Trace
Deduction guide for Trace.
See declaration
template<class NestedDerived>
Trace(const FunctionBase<NestedDerived>& operand) -> Trace< FunctionBase< NestedDerived > >
Trace
Deduction guide for Trace.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Trace(const ShapeFunctionBase<NestedDerived, FES, Space>& operand) -> Trace< ShapeFunctionBase< NestedDerived, FES, Space > >
Transpose
Deduction guide for function transpose.
See declaration
template<class NestedDerived>
Transpose(const FunctionBase<NestedDerived>& m) -> Transpose< FunctionBase< NestedDerived > >
Transpose
Deduction guide for ShapeFunction transpose.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Transpose(const ShapeFunctionBase<NestedDerived, FES, Space>& m) -> Transpose< ShapeFunctionBase< NestedDerived, FES, Space > >
TrialFunction
Deduction guide for TrialFunction.
See declaration
template<class FES>
TrialFunction(const FES& fes) -> TrialFunction< GridFunction< FES, Math::Vector< typename FormLanguage::Traits< FES >::ScalarType > >, FES >
UnaryMinus
Deduction guide for UnaryMinus of FunctionBase.
See declaration
template<class NestedDerived>
UnaryMinus(const FunctionBase<NestedDerived>& op) -> UnaryMinus< FunctionBase< NestedDerived > >
template<class NestedDerived>
auto operator-(const FunctionBase<NestedDerived>& op) -> auto constexpr
Applies unary minus to a function.
UnaryMinus
Deduction guide for UnaryMinus of ShapeFunctionBase.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
UnaryMinus(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> UnaryMinus< ShapeFunctionBase< NestedDerived, FES, Space > >
operator-
Applies unary minus to a shape function.
See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
auto operator-(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> auto constexpr
UnaryMinus
Deduction guide for UnaryMinus of LinearFormIntegratorBase.
See declaration
template<class Number>
UnaryMinus(const LinearFormIntegratorBase<Number>& op) -> UnaryMinus< LinearFormIntegratorBase< Number > >
operator-
Applies unary minus to a linear form integrator.
See declaration
template<class Number>
auto operator-(const LinearFormIntegratorBase<Number>& lfi) -> UnaryMinus<LinearFormIntegratorBase<Number>>
UnaryMinus
Deduction guide for UnaryMinus of List<LinearFormIntegratorBase>.
See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<LinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< LinearFormIntegratorBase< Number > > >
operator-
Applies unary minus to a list of linear form integrators.
See declaration
template<class Number>
auto operator-(const FormLanguage::List<LinearFormIntegratorBase<Number>>& op) -> UnaryMinus<FormLanguage::List<LinearFormIntegratorBase<Number>>>
UnaryMinus
Deduction guide for UnaryMinus of LocalBilinearFormIntegratorBase.
See declaration
template<class Number>
UnaryMinus(const LocalBilinearFormIntegratorBase<Number>& op) -> UnaryMinus< LocalBilinearFormIntegratorBase< Number > >
template<class Number>
auto operator-(const LocalBilinearFormIntegratorBase<Number>& op) -> auto constexpr
Applies unary minus to a bilinear form integrator.
UnaryMinus
Deduction guide for UnaryMinus of List<LocalBilinearFormIntegratorBase>.
See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< LocalBilinearFormIntegratorBase< Number > > >
operator-
Applies unary minus to a list of bilinear form integrators.
See declaration
template<class Number>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>& op) -> auto constexpr
UnaryMinus
Deduction guide for UnaryMinus of GlobalBilinearFormIntegratorBase.
See declaration
template<class Number>
UnaryMinus(const GlobalBilinearFormIntegratorBase<Number>& op) -> UnaryMinus< GlobalBilinearFormIntegratorBase< Number > >
template<class Number>
auto operator-(const GlobalBilinearFormIntegratorBase<Number>& op) -> auto constexpr
Applies unary minus to a bilinear form integrator.
UnaryMinus
Deduction guide for UnaryMinus of List<GlobalBilinearFormIntegratorBase>.
See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<GlobalBilinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< GlobalBilinearFormIntegratorBase< Number > > >
operator-
Applies unary minus to a list of bilinear form integrators.
See declaration
template<class Number>
auto operator-(const FormLanguage::List<GlobalBilinearFormIntegratorBase<Number>>& op) -> auto constexpr
template<class Scalar>
VectorFunction(const Math::Vector<Scalar>& v) -> VectorFunction< Math::Vector< Scalar > >
CTAD for dense-vector constants.
template<class Scalar>
VectorFunction(const Eigen::VectorX<Scalar>& v) -> VectorFunction< Math::Vector< Scalar > >
CTAD for native Eigen dense-vector constants.
template<class V, class... Values>
VectorFunction(const V& v, const Values&... values) -> VectorFunction< V, Values... >
CTAD for component-wise vector functions.
VectorFunction
CTAD for callable vector functions.
See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_v<F, const Geometry::Point&>>>
VectorFunction(size_t vdim, F f) -> VectorFunction< F >
Zero() -> Zero< Real >
CTAD (Class Template Argument Deduction) for scalar Zero.
Zero(size_t vdim) -> Zero< Math::SpatialVector< Real > >
CTAD for vector Zero.
operator+
Addition operator for two functions.
See declaration
template<class LHSDerived, class RHSDerived>
auto operator+(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
template<class LHSDerived>
auto operator+(const FunctionBase<LHSDerived>& lhs, Real rhs) -> auto constexpr
Addition of function and scalar.
template<class RHSDerived>
auto operator+(Real lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Addition of scalar and function.
template<class LHSDerived>
auto operator+(const FunctionBase<LHSDerived>& lhs, Complex rhs) -> auto constexpr
Addition of function and complex scalar.
template<class RHSDerived>
auto operator+(Complex lhs, const FunctionBase<RHSDerived>& rhs) -> auto constexpr
Addition of complex scalar and function.

Variables

template<class LHSDerived, class RHSDerived>
AND< BooleanFunctionBase< LHSDerived >, BooleanFunctionBase< RHSDerived > >
Deduction guide for AND.
template<class LHSDerived, class RHSDerived>
EQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Deduction guide for EQ.
static const ShapeFunctionSpaceType TrialSpace constexpr
Shorthand variable for ShapeFunctionSpaceType::Trial.
static const ShapeFunctionSpaceType TestSpace constexpr
Shorthand variable for ShapeFunctionSpaceType::Test.
template<class LHSDerived, class RHSDerived>
GEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
CTAD for GEQ.
template<class LHSDerived, class RHSDerived>
GT< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
CTAD for GT.
template<class LHSDerived, class RHSDerived>
LEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Deduction guide for LEQ.
template<class LHSDerived, class RHSDerived>
LT< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
CTAD for LT.
template<class LHSDerived, class RHSDerived>
NEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >
Deduction guide for NEQ.
template<class LHSDerived, class RHSDerived>
OR< BooleanFunctionBase< LHSDerived >, BooleanFunctionBase< RHSDerived > >
Deduction guide for OR.

Enum documentation

enum class Rodin::Variational::AssemblyTarget

Defined in Rodin/Variational/ForwardDecls.h

Target for partial problem assembly.

The default zero-argument Problem::assemble() assembles the full linear system. This target selects one side of the system for backends that can assemble the operator and vector independently.

Enumerators
LHS

Assemble the left-hand-side operator only.
RHS

Assemble the right-hand-side vector only.

Typedef documentation

template<class Scalar>
using EssentialBoundary = FormLanguage::List<DirichletBCBase<Scalar>>

Defined in Rodin/Variational/DirichletBC.h

Alias for a list of Dirichlet boundary conditions.

template<size_t K>
using RealH1Element = H1Element<K, Real>

Defined in Rodin/Variational/H1/ForwardDecls.h

Convenience alias for real-valued H1 element.

Template parameters
K Polynomial degree

Equivalent to H1Element<K, Real>. Used for scalar-valued problems such as the Poisson equation or heat conduction.

template<size_t K>
using ComplexH1Element = H1Element<K, Complex>

Defined in Rodin/Variational/H1/ForwardDecls.h

Convenience alias for complex-valued H1 element.

Template parameters
K Polynomial degree

Equivalent to H1Element<K, Complex>. Used for complex-valued problems such as wave equations in frequency domain.

template<size_t K>
using VectorH1Element = H1Element<K, Math::SpatialVector<Real>>

Defined in Rodin/Variational/H1/ForwardDecls.h

Convenience alias for real vector-valued H1 element.

Template parameters
K Polynomial degree

Equivalent to H1Element<K, Math::SpatialVector<Real>>. Used for vector-valued problems such as linear elasticity or fluid mechanics.

template<size_t K>
using ComplexVectorH1Element = H1Element<K, Math::SpatialVector<Complex>>

Defined in Rodin/Variational/H1/ForwardDecls.h

Convenience alias for complex vector-valued H1 element.

Template parameters
K Polynomial degree

Equivalent to H1Element<K, Math::SpatialVector<Complex>>. Used for complex vector-valued problems such as electromagnetic wave propagation.

template<size_t K, class Mesh>
using RealH1 = H1<K, Real, Mesh>

Defined in Rodin/Variational/H1/H1.h

Alias for a scalar real-valued H1 finite element space.

template<size_t K, class Mesh>
using ComplexH1 = H1<K, Complex, Mesh>

Defined in Rodin/Variational/H1/H1.h

Alias for a scalar complex-valued H1 finite element space.

template<size_t K, class Mesh>
using VectorH1 = H1<K, Math::SpatialVector<Real>, Mesh>

Defined in Rodin/Variational/H1/H1.h

Alias for a vector-valued real H1 finite element space.

template<size_t K, class Mesh>
using MatrixH1 = H1<K, Math::SpatialMatrix<Real>, Mesh>

Defined in Rodin/Variational/H1/H1.h

Matrix-valued continuous finite element space of compile-time degree.

template<class Mesh>
using RealP0 = P0<Real, Mesh>

Defined in Rodin/Variational/P0/P0.h

Alias for a scalar real-valued P0 finite element space.

template<class Mesh>
using ComplexP0 = P0<Complex, Mesh>

Defined in Rodin/Variational/P0/P0.h

Alias for a scalar complex-valued P0 finite element space.

template<class Mesh>
using MatrixP0 = P0<Math::SpatialMatrix<Real>, Mesh>

Defined in Rodin/Variational/P0/P0.h

Matrix-valued discontinuous constant finite element space.

template<class Mesh>
using RealP0g = P0g<Real, Mesh>

Defined in Rodin/Variational/P0g/P0g.h

Cellwise-constant real space with a global basis.

template<class Mesh>
using ComplexP0g = P0g<Complex, Mesh>

Defined in Rodin/Variational/P0g/P0g.h

Cellwise-constant complex space with a global basis.

template<class Mesh>
using VectorP0g = P0g<Math::SpatialVector<Real>, Mesh>

Defined in Rodin/Variational/P0g/P0g.h

Cellwise-constant vector-valued space with a global basis.

template<class Mesh>
using MatrixP0g = P0g<Math::SpatialMatrix<Real>, Mesh>

Defined in Rodin/Variational/P0g/P0g.h

Matrix-valued globally constant finite element space.

template<class Scalar>
using VectorP1Element = P1Element<Math::SpatialVector<Scalar>>

Alias for P1Element<Math::SpatialVector<Scalar>>.

Template parameters
Scalar Scalar type for vector components

template<class Mesh>
using RealP1 = P1<Real, Mesh>

Defined in Rodin/Variational/P1/P1.h

Alias for a scalar real-valued P1 finite element space.

template<class Mesh>
using ComplexP1 = P1<Complex, Mesh>

Defined in Rodin/Variational/P1/P1.h

Alias for a scalar complex-valued P1 finite element space.

template<class Mesh>
using VectorP1 = P1<Math::SpatialVector<Real>, Mesh>

Defined in Rodin/Variational/P1/P1.h

Alias for a vector-valued real P1 finite element space.

template<class Mesh>
using MatrixP1 = P1<Math::SpatialMatrix<Real>, Mesh>

Defined in Rodin/Variational/P1/P1.h

Matrix-valued continuous linear finite element space.

template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
using P1DivTrialIntegrand = Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>>, P1<Math::SpatialVector<Real>, LHSMesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Real, RHSMesh>, TestSpace>, P1<Real, RHSMesh>, TestSpace>>

Defined in Rodin/Variational/P1/QuadratureRule.h

Integrand type of the P1 divergence trial term.

template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
using P1DivTestIntegrand = Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Real, LHSMesh>, TrialSpace>, P1<Real, LHSMesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>, P1<Math::SpatialVector<Real>, RHSMesh>, TestSpace>>

Defined in Rodin/Variational/P1/QuadratureRule.h

Integrand type of the P1 divergence test term.

template<class Scalar>
using PeriodicBoundary = FormLanguage::List<PeriodicBCBase<Scalar>>

Defined in Rodin/Variational/PeriodicBC.h

Alias for a list of peridodic boundary conditions.

template<class Scalar>
using VectorZero = Zero<Math::SpatialVector<Scalar>>

Defined in Rodin/Variational/Zero.h

Convenience typedef for vector zero function.

Template parameters
Scalar Scalar type for vector components

Function documentation

Interpolation

Defined in Rodin/MPI/Variational/Interpolation.h

See declaration
template<class FES, class Pred>
Interpolation(const FES& fes, Geometry::Region region, const Pred& pred) -> Interpolation< FES >

Deduces the space that defines the interpolation functionals.

Template parameters
FES Distributed finite element space type.
Pred Entity predicate type.
Parameters
fes Space defining the interpolation functionals.
region Region of eligible interpolation entities.
pred Consistent eligibility predicate.

template<class Vector, class Scalar>
auto operator-(const ProblemBody<::Mat, Vector, Scalar>& pb, const BilinearFormBase<::Mat>& bf)

Defined in Rodin/PETSc/Variational/Problem.h

Subtracts an owned PETSc bilinear-form snapshot.

Parameters
pb Variational problem to operate on.
bf Bilinear form.
Returns Difference of the operands, or the negated operand for the unary overload.

template<class Operator, class Scalar>
auto operator+(const ProblemBody<Operator, ::Vec, Scalar>& pb, const LinearFormBase<::Vec>& lf)

Defined in Rodin/PETSc/Variational/Problem.h

Adds a PETSc linear form to the residual, hence negates its load.

Parameters
pb Variational problem to operate on.
lf Linear form.
Returns Sum of the operands.

LinearElasticityForm

Defined in Rodin/Solid/Linear/LinearElasticityForm.h

See declaration
template<class LambdaDerived, class MuDerived, class Solution, class FES>
LinearElasticityForm(const FunctionBase<LambdaDerived>& lambda, const FunctionBase<MuDerived>& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, LambdaDerived, MuDerived >

Deduction guide for two function Lamé parameters.

Parameters
lambda First Lamé parameter.
mu Shear modulus.
u Trial function.
v Test function.

LinearElasticityForm

Defined in Rodin/Solid/Linear/LinearElasticityForm.h

See declaration
template<class LambdaDerived, class M, class Solution, class FES>
LinearElasticityForm(const FunctionBase<LambdaDerived>& lambda, const M& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, LambdaDerived, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< M > > >::Type >

Deduction guide for a function first parameter and a lifted shear modulus.

Parameters
lambda First Lamé parameter.
mu Shear modulus.
u Trial function.
v Test function.

LinearElasticityForm

Defined in Rodin/Solid/Linear/LinearElasticityForm.h

See declaration
template<class L, class MuDerived, class Solution, class FES>
LinearElasticityForm(const L& lambda, const FunctionBase<MuDerived>& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type, MuDerived >

Deduction guide for a lifted first parameter and a function shear modulus.

Parameters
lambda First Lamé parameter.
mu Shear modulus.
u Trial function.
v Test function.

LinearElasticityForm

Defined in Rodin/Solid/Linear/LinearElasticityForm.h

See declaration
template<class L, class M, class Solution, class FES>
LinearElasticityForm(const L& lambda, const M& mu, const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityForm< Solution, FES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Traits< FES >::ScalarType >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L > &&!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L > &&!std::is_base_of_v< FormLanguage::Base, M >, FormLanguage::FunctionDerived< RealFunction< M > > >::Type >

Deduction guide for two lifted Lamé parameters.

Parameters
lambda First Lamé parameter.
mu Shear modulus.
u Trial function.
v Test function.

LinearElasticityIntegrator

Defined in Rodin/Solid/Linear/LinearElasticityIntegral.h

See declaration
template<class Solution, class FES, class LambdaDerived, class MuDerived>
LinearElasticityIntegrator(const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v, const FunctionBase<LambdaDerived>& lambda, const FunctionBase<MuDerived>& mu) -> LinearElasticityIntegrator< Solution, FES, LambdaDerived, MuDerived >

Deduction guide for LinearElasticityIntegrator.

Parameters
u Trial function (displacement)
v Test function
lambda First Lamé parameter function
mu Second Lamé parameter (shear modulus) function

LinearElasticityIntegral

Defined in Rodin/Solid/Linear/LinearElasticityIntegral.h

See declaration
template<class Solution, class FES>
LinearElasticityIntegral(const TrialFunction<Solution, FES>& u, const TestFunction<FES>& v) -> LinearElasticityIntegral< Solution, FES >

Deduction guide for LinearElasticityIntegral.

Parameters
u Trial function (displacement)
v Test function

Abs

Defined in Rodin/Variational/Abs.h

See declaration
template<class NestedDerived>
Abs(const FunctionBase<NestedDerived>& v) -> Abs< FunctionBase< NestedDerived > >

Deduction guide for Abs.

Parameters
v Function to take absolute value of

template<class NestedDerived>
auto abs(const FunctionBase<NestedDerived>& op) constexpr

Defined in Rodin/Variational/Abs.h

Builds the pointwise absolute value of a function expression.

Parameters
op Function operand.
Returns Pointwise absolute-value expression.

template<class LHSDerived, class RHSDerived>
auto operator&&(const BooleanFunctionBase<LHSDerived>& lhs, const BooleanFunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/AND.h

Logical AND operator for boolean functions.

Parameters
lhs Left-hand side boolean function
rhs Right-hand side boolean function
Returns AND object representing $ lhs \land rhs $

template<class RHSDerived>
auto operator&&(Boolean lhs, const BooleanFunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/AND.h

Logical AND with boolean constant on left.

Parameters
lhs Boolean constant
rhs Boolean function
Returns AND object

template<class LHSDerived>
auto operator&&(const BooleanFunctionBase<LHSDerived>& lhs, Boolean rhs) constexpr

Defined in Rodin/Variational/AND.h

Logical AND with boolean constant on right.

Parameters
lhs Boolean function
rhs Boolean constant
Returns AND object

Average

Defined in Rodin/Variational/Average.h

See declaration
template<class Derived>
Average(const FunctionBase<Derived>& op) -> Average< FunctionBase< Derived > >

Deduction guide for Average with FunctionBase.

Parameters
op Shape function to average

Average

Defined in Rodin/Variational/Average.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Average(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> Average< ShapeFunctionBase< NestedDerived, FES, Space > >

Deduction guide for Average with ShapeFunctionBase.

Parameters
op Shape function to average

BilinearForm

Defined in Rodin/Variational/BilinearForm.h

See declaration
template<class Solution, class TrialFES, class TestFES>
BilinearForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> BilinearForm< Solution, TrialFES, TestFES, Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType > ::Type > >

Deduces the default sparse bilinear form type.

Parameters
u Function operand.
v Function operand.

BooleanFunction

Defined in Rodin/Variational/BooleanFunction.h

See declaration
BooleanFunction(Boolean v) -> BooleanFunction< Boolean >

Deduction guide for BooleanFunction.

Parameters
v Constant Boolean value.

BoundaryIntegral

Defined in Rodin/Variational/BoundaryIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
BoundaryIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> BoundaryIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for BoundaryIntegral.

Parameters
integrand Expression to integrate.

BoundaryIntegral

Defined in Rodin/Variational/BoundaryIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
BoundaryIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> BoundaryIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for BoundaryIntegral.

Parameters
lhs Left operand.
rhs Right operand.

BoundaryIntegral

Defined in Rodin/Variational/BoundaryIntegral.h

See declaration
template<class NestedDerived, class FES>
BoundaryIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> BoundaryIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >

Deduction guide for BoundaryIntegral.

Parameters
integrand Expression to integrate.

BoundaryIntegral

Defined in Rodin/Variational/BoundaryIntegral.h

See declaration
template<class LHSDerived, class RHSDerived, class FES>
BoundaryIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> BoundaryIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >

Deduction guide for BoundaryIntegral.

Parameters
lhs Left operand.
rhs Right operand.

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
ComplexFunction(Integer x) -> ComplexFunction< Integer >

Deduction guide for integer constants.

Parameters
x Constant integer value

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
ComplexFunction(Real x) -> ComplexFunction< Real >

Deduction guide for real constants.

Parameters
x Constant Real value

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
ComplexFunction(const Complex& x) -> ComplexFunction< Complex >

CTAD for ComplexFunction.

Parameters
x Constant scalar value

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
template<class Derived>
ComplexFunction(const FunctionBase<Derived>& nested) -> ComplexFunction< FunctionBase< Derived > >

CTAD for ComplexFunction.

Parameters
nested Function operand.

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
template<class RealNestedDerived, class ImagNestedDerived>
ComplexFunction(const FunctionBase<RealNestedDerived>& re, const FunctionBase<ImagNestedDerived>& imag) -> ComplexFunction< FunctionBase< RealNestedDerived >, FunctionBase< ImagNestedDerived > >

CTAD for ComplexFunction.

Parameters
re Function operand.
imag Function operand.

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_r_v<Complex, F, const Geometry::Point&>>>
ComplexFunction(const F& f) -> ComplexFunction< F >

CTAD for ComplexFunction.

Parameters
f Function operand.

ComplexFunction

Defined in Rodin/Variational/ComplexFunction.h

See declaration
template<class FReal, class FImag, typename = std::enable_if_t<std::is_invocable_v<FReal, const Geometry::Point&>&& std::is_invocable_v<FImag, const Geometry::Point&>>>
ComplexFunction(const FReal& re, const FImag& imag) -> ComplexFunction< FReal, FImag >

CTAD for ComplexFunction.

Parameters
re Real-part function.
imag Imaginary-part function.

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class OperandDerived>
Component(const FunctionBase<OperandDerived>& fn, size_t index) -> Component< FunctionBase< OperandDerived >, size_t >

Deduction guide for vector component extraction.

Parameters
fn Vector function to extract component from
index Index of the selected component.

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class OperandDerived>
Component(const FunctionBase<OperandDerived>& u, size_t row, size_t column) -> Component< FunctionBase< OperandDerived >, size_t, size_t >

Deduction guide for matrix entry extraction.

Parameters
u Matrix-valued trial or test function
row Zero-based row index
column Zero-based column index

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class FES, class Data>
Component(GridFunction<FES, Data>& fn, size_t index) -> Component< GridFunction< FES, Data > >

Deduction guide for GridFunction component extraction.

Parameters
fn Vector function to extract component from
index Index of the selected component.

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class OperandDerived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<OperandDerived, FES, Space>& fn, size_t index) -> Component< ShapeFunctionBase< OperandDerived, FES, Space > >

Deduction guide for ShapeFunction component extraction.

Parameters
fn Vector function to extract component from
index Index of the selected component.

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<Derived, FES, Space>& u, size_t row, size_t column) -> Component< ShapeFunctionBase< Derived, FES, Space >, size_t, size_t >

Deduction guide for ShapeFunction component extraction.

Parameters
u Matrix-valued trial or test function
row Zero-based row index
column Zero-based column index

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class Derived>
Component(const FunctionBase<Derived>& operand, size_t row, size_t column, size_t direction) -> Component< FunctionBase< Derived >, size_t, size_t, size_t >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.
row Row component index.
column Column component index.
direction Direction in which the derivative is evaluated.

Component

Defined in Rodin/Variational/Component.h

See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Component(const ShapeFunctionBase<Derived, FES, Space>& operand, size_t row, size_t column, size_t direction) -> Component< ShapeFunctionBase< Derived, FES, Space >, size_t, size_t, size_t >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.
row Row component index.
column Column component index.
direction Direction in which the derivative is evaluated.

Conjugate

Defined in Rodin/Variational/Conjugate.h

See declaration
template<class NestedDerived>
Conjugate(const FunctionBase<NestedDerived>& v) -> Conjugate< FunctionBase< NestedDerived > >

CTAD for Conjugate.

Parameters
v Function to conjugate

Conjugate

Defined in Rodin/Variational/Conjugate.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Conjugate(const ShapeFunctionBase<NestedDerived, FES, Space>& v) -> Conjugate< ShapeFunctionBase< NestedDerived, FES, Space > >

CTAD for Conjugate on shape functions.

Parameters
v Function to conjugate

Cosh

Defined in Rodin/Variational/Cosh.h

See declaration
template<class NestedDerived>
Cosh(const FunctionBase<NestedDerived>& v) -> Cosh< FunctionBase< NestedDerived > >

Deduction guide for Cosh.

Parameters
v Function to apply cosh to

template<class NestedDerived>
auto cosh(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Cosh.h

Helper function to construct objects of type Cosh.

Parameters
f Function operand.
Returns Pointwise hyperbolic-cosine expression.

Cos

Defined in Rodin/Variational/Cosine.h

See declaration
template<class NestedDerived>
Cos(const FunctionBase<NestedDerived>& v) -> Cos< FunctionBase< NestedDerived > >

Deduction guide for Cos.

Parameters
v Function to apply cosine to

template<class NestedDerived>
auto cos(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Cosine.h

Helper function to construct objects of type Cos.

Parameters
f Function operand.
Returns Pointwise cosine expression.

DenseProblem

Defined in Rodin/Variational/DenseProblem.h

See declaration
template<class U, class V>
DenseProblem(U& u, V& v) -> DenseProblem< Math::LinearSystem< Math::Matrix< typename FormLanguage::Traits< typename FormLanguage::Traits< U >::FESType > ::ScalarType >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< V >::FESType > ::ScalarType > >, U, V >

Deduction guide for DenseProblem.

Parameters
u Trial shape function.
v Test shape function.

Derivative

Defined in Rodin/Variational/Derivative.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType SpaceType>
Derivative(size_t i, const ShapeFunction<NestedDerived, FES, SpaceType>& u) -> Derivative< ShapeFunction< NestedDerived, FES, SpaceType > >

Deduction guide for Derivative.

Parameters
i Index of the requested entry.
u Shape-function operand.

template<class Operand>
auto Dx(const Operand& u)

Defined in Rodin/Variational/Derivative.h

Utility function for computing $ \partial_x u $

Parameters
u in GridFunction instance
Returns Expression for the derivative in the first coordinate direction.

Given a scalar function $ u : \mathbb{R}^s \rightarrow \mathbb{R} $ , this function constructs the derivative in the $ x $ direction $ \dfrac{\partial u}{\partial x} $

template<class Operand>
auto Dy(const Operand& u)

Defined in Rodin/Variational/Derivative.h

Utility function for computing $ \partial_y u $

Parameters
u in GridFunction instance
Returns Expression for the derivative in the second coordinate direction.

Given a scalar function $ u : \mathbb{R}^s \rightarrow \mathbb{R} $ , this function constructs the derivative in the $ y $ direction $ \dfrac{\partial u}{\partial y} $

template<class Operand>
auto Dz(const Operand& u)

Defined in Rodin/Variational/Derivative.h

Utility function for computing $ \partial_z u $

Parameters
u in GridFunction instance
Returns Expression for the derivative in the third coordinate direction.

Given a scalar function $ u : \mathbb{R}^s \rightarrow \mathbb{R} $ , this function constructs the derivative in the $ y $ direction $ \dfrac{\partial u}{\partial z} $

Derivative

Defined in Rodin/Variational/Derivative.h

See declaration
template<class FES, class Data>
Derivative(size_t direction, const GridFunction<FES, Data>& operand) -> Derivative< GridFunction< FES, Data > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
direction Direction in which the derivative is evaluated.
operand Operand expression.

Derivative

Defined in Rodin/Variational/Derivative.h

See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Derivative(size_t direction, const ShapeFunction<Derived, FES, Space>& operand) -> Derivative< ShapeFunction< Derived, FES, Space > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
direction Direction in which the derivative is evaluated.
operand Operand expression.

DiffusionForm

Defined in Rodin/Variational/DiffusionForm.h

See declaration
template<class Solution, class TrialFES, class TestFES>
DiffusionForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type >

Deduction guide for the unweighted diffusion form.

Parameters
u Trial function.
v Test function.

DiffusionForm

Defined in Rodin/Variational/DiffusionForm.h

See declaration
template<class CoefficientDerived, class Solution, class TrialFES, class TestFES>
DiffusionForm(const FunctionBase<CoefficientDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, CoefficientDerived >

Deduction guide for the diffusion form weighted by a function.

Parameters
c Coefficient.
u Trial function.
v Test function.

DiffusionForm

Defined in Rodin/Variational/DiffusionForm.h

See declaration
template<class L, class Solution, class TrialFES, class TestFES>
DiffusionForm(const L& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> DiffusionForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type >

Deduction guide for the diffusion form weighted by a lifted value.

Parameters
c Coefficient.
u Trial function.
v Test function.

DirichletBC

Defined in Rodin/Variational/DirichletBC.h

See declaration
template<class Solution, class FES1, class Derived2, class FES2, ShapeFunctionSpaceType Sp, class DefectDerived>
DirichletBC(const TrialFunction<Solution, FES1>& u, const ShapeFunctionBase<Derived2, FES2, Sp>& value, const FunctionBase<DefectDerived>& defect) -> DirichletBC< TrialFunction< Solution, FES1 >, ShapeFunctionBase< Derived2, FES2, Sp > >

Deduction guide for DirichletBC.

Parameters
u Slave trial function
value Boundary value supplied as a shape-function expression.
defect Boundary-value defect function.

Div

Defined in Rodin/Variational/Div.h

See declaration
template<class FES, class Data>
Div(const GridFunction<FES, Data>& operand) -> Div< GridFunction< FES, Data > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.

Div

Defined in Rodin/Variational/Div.h

See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<Derived, FES, Space>& operand) -> Div< ShapeFunction< Derived, FES, Space > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.

Division

Defined in Rodin/Variational/Division.h

See declaration
template<class LHSDerived, class RHSDerived>
Division(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Division< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for Division.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived>
auto operator/(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs)

Defined in Rodin/Variational/Division.h

Division operator for two functions.

Parameters
lhs Numerator function
rhs Denominator function
Returns Division object representing $ \frac{f}{g} $

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>, Division<LHSDerived, RealFunction<Number>>>>
auto operator/(const FunctionBase<LHSDerived>& lhs, Number rhs)

Defined in Rodin/Variational/Division.h

Division of a function by a number.

Parameters
lhs Function to divide
rhs Number to divide by
Returns Division object representing $ \frac{f}{c} $

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>, Division<RHSDerived, RealFunction<Number>>>>
auto operator/(Number lhs, const FunctionBase<RHSDerived>& rhs)

Defined in Rodin/Variational/Division.h

Division of a number by a function.

Parameters
lhs Number in numerator
rhs Function in denominator
Returns Division object representing $ \frac{c}{g} $

Division

Defined in Rodin/Variational/Division.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Division(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Division< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >

Deduction guide for Division.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator/(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs)

Defined in Rodin/Variational/Division.h

Quotient of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Quotient of the operands.

Dot

Defined in Rodin/Variational/Dot.h

See declaration
template<class LHSDerived, class RHSDerived>
Dot(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Dot< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for Dot product of two functions.

Parameters
lhs Left operand.
rhs Right operand.

Dot

Defined in Rodin/Variational/Dot.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Dot(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, Space > >

Deduction guide for Dot product of function and shape function.

Parameters
lhs Left operand.
rhs Right operand.

Dot

Defined in Rodin/Variational/Dot.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Dot(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Dot< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >

Deduction guide for Dot product of shape function and function.

Parameters
lhs Left operand.
rhs Right operand.

Dot

Defined in Rodin/Variational/Dot.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Dot(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >

Deduction guide for Dot product of trial and test shape functions.

Parameters
lhs Left operand.
rhs Right operand.

Dot

Defined in Rodin/Variational/Dot.h

See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Dot(const Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > >

Deduction guide for Dot product of potential and test shape function.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived>
auto operator==(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/EQ.h

Equality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare equal.

template<class RHSDerived>
auto operator==(Boolean lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/EQ.h

Equality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare equal.

template<class LHSDerived>
auto operator==(const FunctionBase<LHSDerived>& lhs, Boolean rhs) constexpr

Defined in Rodin/Variational/EQ.h

Equality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare equal.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator==(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/EQ.h

Equality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare equal.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator==(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/EQ.h

Equality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare equal.

UndeterminedTraceDomainException

Defined in Rodin/Variational/Exceptions/UndeterminedTraceDomainException.h

See declaration
template<class T, class FuncName, class Iterator>
UndeterminedTraceDomainException(const T& cls, const FuncName& funcName, const std::pair<size_t, Index>& p, Iterator begin, Iterator end) -> UndeterminedTraceDomainException< T, FuncName >

Deduction guide for UndeterminedTraceDomainException.

Parameters
cls Object whose trace domain could not be determined.
funcName Name of the function reporting the error.
p Entity identified by its dimension and local index.
begin Iterator to the first entry.
end Iterator past the last entry.

Exp

Defined in Rodin/Variational/Exp.h

See declaration
template<class NestedDerived>
Exp(const FunctionBase<NestedDerived>& v) -> Exp< FunctionBase< NestedDerived > >

Deduction guide for Exp.

Parameters
v Function to exponentiate

template<class NestedDerived>
auto exp(const FunctionBase<NestedDerived>& op) constexpr

Defined in Rodin/Variational/Exp.h

Builds the pointwise exponential of a function expression.

Parameters
op Function operand.
Returns Pointwise exponential expression.

FaceIntegral

Defined in Rodin/Variational/FaceIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
FaceIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& prod) -> FaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for FaceIntegral.

Parameters
prod Dot product of trial and test operators

FaceIntegral

Defined in Rodin/Variational/FaceIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
FaceIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> FaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for FaceIntegral.

Parameters
lhs Left operand.
rhs Right operand.

FaceIntegral

Defined in Rodin/Variational/FaceIntegral.h

See declaration
template<class NestedDerived, class FES>
FaceIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& prod) -> FaceIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >

Deduction guide for FaceIntegral.

Parameters
prod Dot product of trial and test operators

FaceIntegral

Defined in Rodin/Variational/FaceIntegral.h

See declaration
template<class LHSDerived, class RHSDerived, class FES>
FaceIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> FaceIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >

Deduction guide for FaceIntegral.

Parameters
lhs Left operand.
rhs Right operand.

Flow

Defined in Rodin/Variational/Flow.h

See declaration
template<class Derived, class Velocity>
Flow(const Real& time, const FunctionBase<Derived>& operand, Velocity&& velocity) -> Flow< FunctionBase< Derived >, Velocity, Math::RungeKutta::RK4, DefaultBoundaryPolicy >

Deduction guide for Flow.

Parameters
time Duration of the flow integration.
operand Function transported along the flow.
velocity Velocity field.

Flow

Defined in Rodin/Variational/Flow.h

See declaration
template<class Derived, class Velocity, class Step>
Flow(const Real& time, const FunctionBase<Derived>& operand, Velocity&& velocity, Step&& stepper) -> Flow< FunctionBase< Derived >, Velocity, Step, DefaultBoundaryPolicy >

Deduction guide for Flow.

Parameters
time Duration of the flow integration.
operand Function transported along the flow.
velocity Velocity field.
stepper Time integration method.

Flow

Defined in Rodin/Variational/Flow.h

See declaration
template<class Derived, class Velocity, class Step, class BBP>
Flow(const Real& t, const FunctionBase<Derived>& u, Velocity&& vel, Step&& st, BBP&& bp) -> Flow< FunctionBase< Derived >, Velocity, Step, BBP >

Deduction guide for Flow.

Parameters
t Signed tracing time.
u Operand function.
vel Velocity field.
st Time integrator.
bp Boundary policy.

Frobenius

Defined in Rodin/Variational/Frobenius.h

See declaration
template<class NestedDerived>
Frobenius(const FunctionBase<NestedDerived>& v) -> Frobenius< FunctionBase< NestedDerived > >

Deduction guide for Frobenius norm.

Parameters
v Function to compute the norm of

template<class Derived>
Optional<size_t> GetOrderIfConstant(const FunctionBase<Derived>& f, const Geometry::Polytope& polytope) noexcept

Defined in Rodin/Variational/Function.h

Returns the order only when a function is elementwise constant.

Parameters
f Function operand.
polytope Mesh entity used by this operation.
Returns Zero when the function is known to be elementwise constant, or an empty optional otherwise.

template<class LHSDerived, class RHSDerived>
auto operator>=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/GEQ.h

Greater-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is greater than or equal to the right operand.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>=(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/GEQ.h

Greater-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is greater than or equal to the right operand.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>=(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/GEQ.h

Greater-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is greater than or equal to the right operand.

GridFunction

Defined in Rodin/Variational/GridFunction.h

See declaration
template<class FES>
GridFunction(const FES& fes) -> GridFunction< FES, Math::Vector< typename FormLanguage::Traits< FES >::ScalarType > >

Deduces the default dense-vector grid function type.

Parameters
fes Finite element space.

GridFunction

Defined in Rodin/Variational/GridFunction.h

See declaration
template<class FES, class Data>
GridFunction(const FES& fes, Data&& data) -> GridFunction< FES, Data >

Deduces a grid function type from a finite element space and data object.

Parameters
fes Finite element space.
data Data used by the operation.

template<class LHSDerived, class RHSDerived>
auto operator>(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/GT.h

Greater-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand follows the right operand.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/GT.h

Greater-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand follows the right operand.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator>(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/GT.h

Greater-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand follows the right operand.

Div

Defined in Rodin/Variational/H1/Div.h

See declaration
template<size_t K, class NestedDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, H1< K, Math::SpatialVector< Number >, Mesh >, Space > >

Deduction guide for Div.

Parameters
u Operand expression.

H1

Defined in Rodin/Variational/H1/H1.h

See declaration
template<size_t K, class Context>
H1(std::integral_constant<size_t, K> orderTag, const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> H1< K, Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >

Deduces a matrix range from explicit rows and columns.

Parameters
orderTag Compile-time polynomial order tag.
mesh Mesh supporting the finite element space.
rows Number of rows in the value range.
cols Number of columns in the value range.

Jacobian

Defined in Rodin/Variational/H1/Jacobian.h

See declaration
template<size_t K, class ShapeFunctionDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, H1<K, Math::SpatialVector<Number>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, H1< K, Math::SpatialVector< Number >, Mesh >, Space > >

Deduction guide for Jacobian.

Parameters
u Operand expression.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t K, class NestedDerived, class Scalar, class Mesh>
QuadratureRule(const ShapeFunctionBase<ShapeFunction<NestedDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>& integrand) -> QuadratureRule< ShapeFunctionBase< ShapeFunction< NestedDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t K, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const ShapeFunctionBase<Dot<FunctionBase<LHSDerived>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<K, Scalar, Mesh>, TestSpace>, H1<K, Scalar, Mesh>, TestSpace>>, H1<K, Scalar, Mesh>, TestSpace>& integrand) -> QuadratureRule< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< K, Scalar, Mesh >, TestSpace >, H1< K, Scalar, Mesh >, TestSpace > >, H1< K, Scalar, Mesh >, TestSpace > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class TrialRange, class TestRange, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Div<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>, H1<KTest, TestRange, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Div< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace > >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace >, H1< KTest, TestRange, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class TrialRange, class TestRange, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, H1<KTrial, TrialRange, Mesh>, TrialSpace>, H1<KTrial, TrialRange, Mesh>, TrialSpace>, ShapeFunctionBase<Div<ShapeFunction<RHSDerived, H1<KTest, TestRange, Mesh>, TestSpace>>, H1<KTest, TestRange, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, H1< KTrial, TrialRange, Mesh >, TrialSpace >, H1< KTrial, TrialRange, Mesh >, TrialSpace >, ShapeFunctionBase< Div< ShapeFunction< RHSDerived, H1< KTest, TestRange, Mesh >, TestSpace > >, H1< KTest, TestRange, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<Jacobian<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< Jacobian< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace > >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/H1/QuadratureRule.h

See declaration
template<size_t KTrial, size_t KTest, class CoefficientDerived, class LHSDerived, class RHSDerived, class Scalar, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<ShapeFunctionBase<Jacobian<ShapeFunction<LHSDerived, H1<KTrial, Scalar, Mesh>, TrialSpace>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, FunctionBase<CoefficientDerived>>, H1<KTrial, Scalar, Mesh>, TrialSpace>, ShapeFunctionBase<ShapeFunction<RHSDerived, H1<KTest, Scalar, Mesh>, TestSpace>, H1<KTest, Scalar, Mesh>, TestSpace>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< ShapeFunctionBase< Jacobian< ShapeFunction< LHSDerived, H1< KTrial, Scalar, Mesh >, TrialSpace > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, FunctionBase< CoefficientDerived > >, H1< KTrial, Scalar, Mesh >, TrialSpace >, ShapeFunctionBase< ShapeFunction< RHSDerived, H1< KTest, Scalar, Mesh >, TestSpace >, H1< KTest, Scalar, Mesh >, TestSpace > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

HelmholtzForm

Defined in Rodin/Variational/HelmholtzForm.h

See declaration
template<class DiffusionDerived, class MassDerived, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const FunctionBase<DiffusionDerived>& a, const FunctionBase<MassDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, DiffusionDerived, MassDerived >

Deduction guide for two function coefficients.

Parameters
a Diffusion coefficient.
c Mass coefficient.
u Trial function.
v Test function.

HelmholtzForm

Defined in Rodin/Variational/HelmholtzForm.h

See declaration
template<class DiffusionDerived, class C, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const FunctionBase<DiffusionDerived>& a, const C& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, DiffusionDerived, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< C > > >::Type >

Deduction guide for a function diffusion and a lifted mass coefficient.

Parameters
a Diffusion coefficient.
c Mass coefficient.
u Trial function.
v Test function.

HelmholtzForm

Defined in Rodin/Variational/HelmholtzForm.h

See declaration
template<class A, class MassDerived, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const A& a, const FunctionBase<MassDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A >, FormLanguage::FunctionDerived< RealFunction< A > > >::Type, MassDerived >

Deduction guide for a lifted diffusion and a function mass coefficient.

Parameters
a Diffusion coefficient.
c Mass coefficient.
u Trial function.
v Test function.

HelmholtzForm

Defined in Rodin/Variational/HelmholtzForm.h

See declaration
template<class A, class C, class Solution, class TrialFES, class TestFES>
HelmholtzForm(const A& a, const C& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> HelmholtzForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A > &&!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< A > > >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, A > &&!std::is_base_of_v< FormLanguage::Base, C >, FormLanguage::FunctionDerived< RealFunction< C > > >::Type >

Deduction guide for two lifted coefficients.

Parameters
a Diffusion coefficient.
c Mass coefficient.
u Trial function.
v Test function.

Im

Defined in Rodin/Variational/Im.h

See declaration
template<class NestedDerived>
Im(const FunctionBase<NestedDerived>& f) -> Im< FunctionBase< NestedDerived > >

CTAD for Im.

Parameters
f Complex-valued function operand

Integral

Defined in Rodin/Variational/Integral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> Integral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for Integral.

Parameters
integrand Expression to integrate.

Integral

Defined in Rodin/Variational/Integral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Integral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for Integral.

Parameters
lhs Left operand.
rhs Right operand.

Integral

Defined in Rodin/Variational/Integral.h

See declaration
template<class NestedDerived, class FES>
Integral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> Integral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >

Deduction guide for Integral.

Parameters
integrand Expression to integrate.

Integral

Defined in Rodin/Variational/Integral.h

See declaration
template<class LHSDerived, class RHSDerived, class FES>
Integral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> Integral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > > > >

Deduction guide for Integral.

Parameters
lhs Left operand.
rhs Right operand.

Integral

Defined in Rodin/Variational/Integral.h

See declaration
template<class FES, class Data>
Integral(const GridFunction<FES, Data>& integrand) -> Integral< GridFunction< FES, Data > >

Deduction guide for Integral.

Parameters
integrand Expression to integrate.

InterfaceIntegral

Defined in Rodin/Variational/InterfaceIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
InterfaceIntegral(const Dot<ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> InterfaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for InterfaceIntegral.

Parameters
integrand Test operator to integrate

InterfaceIntegral

Defined in Rodin/Variational/InterfaceIntegral.h

See declaration
template<class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
InterfaceIntegral(const ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> InterfaceIntegral< Dot< ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for InterfaceIntegral.

Parameters
lhs Function operator (left-hand side)
rhs Test operator (right-hand side)

InterfaceIntegral

Defined in Rodin/Variational/InterfaceIntegral.h

See declaration
template<class NestedDerived, class FES>
InterfaceIntegral(const ShapeFunctionBase<NestedDerived, FES, TestSpace>& integrand) -> InterfaceIntegral< ShapeFunctionBase< NestedDerived, FES, TestSpace > >

Deduction guide for InterfaceIntegral.

Parameters
integrand Test operator to integrate

InterfaceIntegral

Defined in Rodin/Variational/InterfaceIntegral.h

See declaration
template<class LHSDerived, class RHSDerived, class FES>
InterfaceIntegral(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, TestSpace>& rhs) -> InterfaceIntegral< ShapeFunctionBase< Dot< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, TestSpace > >, FES, TestSpace > >

Deduction guide for InterfaceIntegral.

Parameters
lhs Function operator (left-hand side)
rhs Test operator (right-hand side)

Jacobian

Defined in Rodin/Variational/Jacobian.h

See declaration
template<class FES, class Data>
Jacobian(const GridFunction<FES, Data>& operand) -> Jacobian< GridFunction< FES, Data > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.

Jacobian

Defined in Rodin/Variational/Jacobian.h

See declaration
template<class Derived, class FES, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<Derived, FES, Space>& operand) -> Jacobian< ShapeFunction< Derived, FES, Space > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
operand Operand expression.

Jump

Defined in Rodin/Variational/Jump.h

See declaration
template<class Derived>
Jump(const FunctionBase<Derived>& op) -> Jump< FunctionBase< Derived > >

Deduction guide for Jump with FunctionBase.

Parameters
op Function to compute the jump of across interfaces

Jump

Defined in Rodin/Variational/Jump.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Jump(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> Jump< ShapeFunctionBase< NestedDerived, FES, Space > >

Deduction guide for Jump with ShapeFunctionBase.

Parameters
op Function to compute the jump of across interfaces

template<class LHSDerived, class RHSDerived>
auto operator<=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/LEQ.h

Less-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is less than or equal to the right operand.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<=(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/LEQ.h

Less-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is less than or equal to the right operand.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<=(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/LEQ.h

Less-or-equal comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand is less than or equal to the right operand.

template<class LHSDerived, class RHSDerived>
auto operator<(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/LT.h

Less-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand precedes the right operand.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/LT.h

Less-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand precedes the right operand.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator<(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/LT.h

Less-than comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the left operand precedes the right operand.

MassForm

Defined in Rodin/Variational/MassForm.h

See declaration
template<class Solution, class TrialFES, class TestFES>
MassForm(const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type >

Deduction guide for the unweighted mass form.

Parameters
u Trial function.
v Test function.

MassForm

Defined in Rodin/Variational/MassForm.h

See declaration
template<class CoefficientDerived, class Solution, class TrialFES, class TestFES>
MassForm(const FunctionBase<CoefficientDerived>& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, CoefficientDerived >

Deduction guide for the mass form weighted by a function.

Parameters
c Coefficient.
u Trial function.
v Test function.

MassForm

Defined in Rodin/Variational/MassForm.h

See declaration
template<class L, class Solution, class TrialFES, class TestFES>
MassForm(const L& c, const TrialFunction<Solution, TrialFES>& u, const TestFunction<TestFES>& v) -> MassForm< Solution, TrialFES, TestFES, typename FormLanguage::NamedFormOperatorType< Solution, typename FormLanguage::Mult< typename FormLanguage::Traits< TrialFES >::ScalarType, typename FormLanguage::Traits< TestFES >::ScalarType >::Type >::Type, typename std::enable_if_t<!std::is_base_of_v< FormLanguage::Base, L >, FormLanguage::FunctionDerived< RealFunction< L > > >::Type >

Deduction guide for the mass form weighted by a lifted value.

Parameters
c Coefficient.
u Trial function.
v Test function.

MatrixFunction

Defined in Rodin/Variational/MatrixFunction.h

See declaration
template<class Scalar>
MatrixFunction(const Math::Matrix<Scalar>& matrix) -> MatrixFunction< Math::Matrix< Scalar > >

Deduction guide for MatrixFunction.

Parameters
matrix Matrix operand.

MatrixFunction

Defined in Rodin/Variational/MatrixFunction.h

See declaration
template<class Scalar>
MatrixFunction(const Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic>& matrix) -> MatrixFunction< Math::Matrix< Scalar > >

Deduces a dense matrix coefficient from native Eigen storage.

Template parameters
Scalar Matrix scalar type.
Parameters
matrix Matrix whose value is copied into the coefficient.

MatrixFunction

Defined in Rodin/Variational/MatrixFunction.h

See declaration
template<class Scalar>
MatrixFunction(const Math::SpatialMatrix<Scalar>& matrix) -> MatrixFunction< Math::SpatialMatrix< Scalar > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
matrix Matrix operand.

MatrixFunction

Defined in Rodin/Variational/MatrixFunction.h

See declaration
template<class F>
MatrixFunction(size_t rows, size_t columns, F function) -> MatrixFunction< F >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
rows Number of rows.
columns Number of matrix columns.
function Function to evaluate.

Max

Defined in Rodin/Variational/Max.h

See declaration
template<class LHSDerived, class RHSDerived>
Max(const FunctionBase<LHSDerived>& a, const FunctionBase<RHSDerived>& b) -> Max< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for Max.

Parameters
a First function
b Second function

Max

Defined in Rodin/Variational/Max.h

See declaration
template<class NestedDerived>
Max(const FunctionBase<NestedDerived>& a, Real b) -> Max< FunctionBase< NestedDerived >, Real >

Deduction guide for Max.

Parameters
a First function
b Second function

Max

Defined in Rodin/Variational/Max.h

See declaration
template<class NestedDerived>
Max(Real a, const FunctionBase<NestedDerived>& b) -> Max< Real, FunctionBase< NestedDerived > >

Deduction guide for Max.

Parameters
a First function
b Second function

Min

Defined in Rodin/Variational/Min.h

See declaration
template<class LHSDerived, class RHSDerived>
Min(const FunctionBase<LHSDerived>& a, const FunctionBase<RHSDerived>& b) -> Min< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for Min.

Parameters
a Left operand.
b Right operand.

Min

Defined in Rodin/Variational/Min.h

See declaration
template<class NestedDerived>
Min(const FunctionBase<NestedDerived>& a, Real b) -> Min< FunctionBase< NestedDerived >, Real >

Deduction guide for Min.

Parameters
a Left operand.
b Right operand.

Min

Defined in Rodin/Variational/Min.h

See declaration
template<class NestedDerived>
Min(Real a, const FunctionBase<NestedDerived>& b) -> Min< Real, FunctionBase< NestedDerived > >

Deduction guide for Min.

Parameters
a Left operand.
b Right operand.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator-(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts a number from a function.

Parameters
lhs Function operand
rhs Number operand
Returns Difference function $ f - c $
\[ (f - c)(x) = f(x) - c \]

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator-(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts a function from a number.

Parameters
lhs Number operand
rhs Function operand
Returns Difference function $ c - f $
\[ (c - f)(x) = c - f(x) \]

template<class LHSDerived, class RHSDerived>
auto operator-(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts two functions.

Parameters
lhs First function
rhs Second function
Returns Difference function $ f - g $
\[ (f - g)(x) = f(x) - g(x) \]

template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator-(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts two shape functions.

Parameters
lhs First shape function
rhs Second shape function
Returns Difference shape function $ u - v $
\[ (u - v)_i = u_i - v_i \]

template<class LHSNumber, class RHSNumber>
auto operator-(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts two bilinear form integrators.

Parameters
lhs First integrator
rhs Second integrator
Returns Difference integrator

template<class LHSNumber, class RHSNumber>
auto operator-(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts a list of bilinear form integrators from a single integrator.

Parameters
lhs Single integrator
rhs List of integrators
Returns Difference integrator list

template<class LHSNumber, class RHSNumber>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts a single bilinear form integrator from a list.

Parameters
lhs List of integrators
rhs Single integrator
Returns Difference integrator list

template<class LHSNumber, class RHSNumber>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Minus.h

Subtracts two lists of bilinear form integrators.

Parameters
lhs First integrator list
rhs Second integrator list
Returns Difference integrator list

Mult

Defined in Rodin/Variational/Mult.h

See declaration
template<class LHSDerived, class RHSDerived>
Mult(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Mult< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for Mult of two FunctionBase instances.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Multiplies two functions.

Parameters
lhs Left function
rhs Right function
Returns Product function $ f \cdot g $

template<class RHSDerived>
auto operator*(Real lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Multiplies a real number by a function (scalar multiplication).

Parameters
lhs Scalar multiplier
rhs Function to scale
Returns Scaled function $ c \cdot f $

template<class RHSDerived>
auto operator*(Complex lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Multiplies a complex number by a function (scalar multiplication).

Parameters
lhs Complex multiplier
rhs Function to scale
Returns Scaled function $ z \cdot f $

template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, Real rhs) constexpr

Defined in Rodin/Variational/Mult.h

Multiplies a function by a real number (scalar multiplication).

Parameters
lhs Function to scale
rhs Scalar multiplier
Returns Scaled function $ f \cdot c $

template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, Complex rhs) constexpr

Defined in Rodin/Variational/Mult.h

Multiplies a function by a complex number (scalar multiplication).

Parameters
lhs Function to scale
rhs Complex multiplier
Returns Scaled function $ f \cdot z $

template<class LHSDerived>
auto operator*(const FunctionBase<LHSDerived>& lhs, const Math::Matrix<Real>& rhs)

Defined in Rodin/Variational/Mult.h

Product of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class LHSDerived>
auto operator*(const Math::Matrix<Real>& lhs, const FunctionBase<LHSDerived>& rhs)

Defined in Rodin/Variational/Mult.h

Product of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

Mult

Defined in Rodin/Variational/Mult.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Mult(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Mult< FunctionBase< LHSDerived >, ShapeFunctionBase< RHSDerived, FES, Space > >

Deduction guide for Mult.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const FunctionBase<LHSDerived>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const Real& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const Complex& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

Mult

Defined in Rodin/Variational/Mult.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Mult(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) -> Mult< ShapeFunctionBase< LHSDerived, FES, Space >, FunctionBase< RHSDerived > >

Deduction guide for Mult.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class LHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const Real& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class LHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator*(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const Complex& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

Mult

Defined in Rodin/Variational/Mult.h

See declaration
template<class Number, class RHSScalar>
Mult(const Number& lhs, const LocalBilinearFormIntegratorBase<RHSScalar>& rhs) -> Mult< Number, LocalBilinearFormIntegratorBase< RHSScalar > >

Deduction guide for Mult.

Parameters
lhs Left operand.
rhs Right operand.

template<class Number, class RHSScalar>
auto operator*(const Number& lhs, const LocalBilinearFormIntegratorBase<RHSScalar>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two bilinear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

Mult

Defined in Rodin/Variational/Mult.h

See declaration
template<class Number, class RHSScalar>
Mult(const Number& lhs, const LinearFormIntegratorBase<RHSScalar>& rhs) -> Mult< Number, LinearFormIntegratorBase< RHSScalar > >

Deduction guide for Mult.

Parameters
lhs Left operand.
rhs Right operand.

template<class Number, class RHSScalar>
auto operator*(const Number& lhs, const LinearFormIntegratorBase<RHSScalar>& rhs) constexpr

Defined in Rodin/Variational/Mult.h

Product of two linear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Product of the operands.

template<class CoeffDerived, class TrialDerived, class TrialFES, class TestDerived, class TestFES>
auto operator*(const FunctionBase<CoeffDerived>& coeff, const Dot<ShapeFunctionBase<TrialDerived, TrialFES, TrialSpace>, ShapeFunctionBase<TestDerived, TestFES, TestSpace>>& dot) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
coeff Coefficient multiplying the expression.
dot Function operand.
Returns Product of the operands.

template<class TrialDerived, class TrialFES, class TestDerived, class TestFES, class CoeffDerived>
auto operator*(const Dot<ShapeFunctionBase<TrialDerived, TrialFES, TrialSpace>, ShapeFunctionBase<TestDerived, TestFES, TestSpace>>& dot, const FunctionBase<CoeffDerived>& coeff) constexpr

Defined in Rodin/Variational/Mult.h

Product of two shape function expressions.

Parameters
dot Function operand.
coeff Coefficient multiplying the expression.
Returns Product of the operands.

template<class LHSDerived, class RHSDerived>
auto operator!=(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/NEQ.h

Inequality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare unequal.

template<class RHSDerived>
auto operator!=(Boolean lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/NEQ.h

Inequality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare unequal.

template<class LHSDerived>
auto operator!=(const FunctionBase<LHSDerived>& lhs, Boolean rhs) constexpr

Defined in Rodin/Variational/NEQ.h

Inequality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare unequal.

template<class Number, class RHSDerived, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator!=(Number lhs, const FunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/NEQ.h

Inequality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare unequal.

template<class LHSDerived, class Number, typename = std::enable_if_t<std::is_arithmetic_v<Number>>>
auto operator!=(const FunctionBase<LHSDerived>& lhs, Number rhs) constexpr

Defined in Rodin/Variational/NEQ.h

Inequality comparison of two function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Whether the operands compare unequal.

template<class LHSDerived, class RHSDerived>
auto operator||(const BooleanFunctionBase<LHSDerived>& lhs, const BooleanFunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/OR.h

Logical disjunction of two boolean function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Pointwise logical-disjunction expression.

template<class RHSDerived>
auto operator||(Boolean lhs, const BooleanFunctionBase<RHSDerived>& rhs) constexpr

Defined in Rodin/Variational/OR.h

Logical disjunction of two boolean function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Pointwise logical-disjunction expression.

template<class LHSDerived>
auto operator||(const BooleanFunctionBase<LHSDerived>& lhs, Boolean rhs) constexpr

Defined in Rodin/Variational/OR.h

Logical disjunction of two boolean function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Pointwise logical-disjunction expression.

Grad

Defined in Rodin/Variational/P0/Grad.h

See declaration
template<class NestedDerived, class Range, class Mesh, ShapeFunctionSpaceType Space>
Grad(const ShapeFunction<NestedDerived, P0<Range, Mesh>, Space>& operand) -> Grad< ShapeFunction< NestedDerived, P0< Range, Mesh >, Space > >

Deduction guide for Grad.

Parameters
operand Operand expression.

P0

Defined in Rodin/Variational/P0/P0.h

See declaration
template<class Context>
P0(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P0< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >

Deduces a matrix range from explicit rows and columns.

Parameters
mesh Mesh supporting the finite element space.
rows Number of rows in the value range.
cols Number of columns in the value range.

Div

Defined in Rodin/Variational/P0g/Div.h

See declaration
template<class NestedDerived, class Scalar, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space > >

Deduction guide for Div.

Parameters
u Operand expression.

Jacobian

Defined in Rodin/Variational/P0g/Jacobian.h

See declaration
template<class ShapeFunctionDerived, class Scalar, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, P0g<Math::SpatialVector<Scalar>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, P0g< Math::SpatialVector< Scalar >, Mesh >, Space > >

Deduction guide for Jacobian.

Parameters
u Operand expression.

P0g

Defined in Rodin/Variational/P0g/P0g.h

See declaration
template<class Context>
P0g(const Geometry::Mesh<Context>& mesh) -> P0g< Real, Geometry::Mesh< Context > >

Deduction guide for P0g.

Parameters
mesh Mesh supporting the finite element space.

P0g

Defined in Rodin/Variational/P0g/P0g.h

See declaration
template<class Context>
P0g(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P0g< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
mesh Mesh supporting the finite element space.
rows Number of rows in the value range.
cols Number of columns in the value range.

Div

Defined in Rodin/Variational/P1/Div.h

See declaration
template<class NestedDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Div(const ShapeFunction<NestedDerived, P1<Math::SpatialVector<Number>, Mesh>, Space>& u) -> Div< ShapeFunction< NestedDerived, P1< Math::SpatialVector< Number >, Mesh >, Space > >

Deduction guide for Div.

Parameters
u Operand expression.

Jacobian

Defined in Rodin/Variational/P1/Jacobian.h

See declaration
template<class ShapeFunctionDerived, class Number, class Mesh, ShapeFunctionSpaceType Space>
Jacobian(const ShapeFunction<ShapeFunctionDerived, P1<Math::SpatialVector<Number>, Mesh>, Space>& u) -> Jacobian< ShapeFunction< ShapeFunctionDerived, P1< Math::SpatialVector< Number >, Mesh >, Space > >

Deduction guide for Jacobian.

Parameters
u Operand expression.

P1

Defined in Rodin/Variational/P1/P1.h

See declaration
template<class Context>
P1(const Geometry::Mesh<Context>& mesh, size_t rows, size_t cols) -> P1< Math::SpatialMatrix< Real >, Geometry::Mesh< Context > >

Deduces a matrix range from explicit rows and columns.

Parameters
mesh Mesh supporting the finite element space.
rows Number of rows in the value range.
cols Number of columns in the value range.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class CoefficientDerived, class LHSDerived, class RHSDerived, class Number, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Mult<FunctionBase<CoefficientDerived>, ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Number, Mesh>, TrialSpace>>>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Number, Mesh>, TestSpace>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Mult< FunctionBase< CoefficientDerived >, ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Number, Mesh >, TrialSpace > > > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Number, Mesh >, TestSpace > > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Dot<ShapeFunctionBase<Grad<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>>, ShapeFunctionBase<Grad<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Dot< ShapeFunctionBase< Grad< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > > >, ShapeFunctionBase< Grad< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class CoefficientDerived, class LHSDerived, class RHSDerived, class Range, class Mesh>
QuadratureRule(const Mult<FunctionBase<CoefficientDerived>, Dot<ShapeFunctionBase<ShapeFunction<LHSDerived, P1<Range, Mesh>, TrialSpace>>, ShapeFunctionBase<ShapeFunction<RHSDerived, P1<Range, Mesh>, TestSpace>>>>& integrand) -> QuadratureRule< Mult< FunctionBase< CoefficientDerived >, Dot< ShapeFunctionBase< ShapeFunction< LHSDerived, P1< Range, Mesh >, TrialSpace > >, ShapeFunctionBase< ShapeFunction< RHSDerived, P1< Range, Mesh >, TestSpace > > > > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
QuadratureRule(const P1DivTrialIntegrand<LHSDerived, RHSDerived, LHSMesh, RHSMesh>& integrand) -> QuadratureRule< P1DivTrialIntegrand< LHSDerived, RHSDerived, LHSMesh, RHSMesh > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

QuadratureRule

Defined in Rodin/Variational/P1/QuadratureRule.h

See declaration
template<class LHSDerived, class RHSDerived, class LHSMesh, class RHSMesh>
QuadratureRule(const P1DivTestIntegrand<LHSDerived, RHSDerived, LHSMesh, RHSMesh>& integrand) -> QuadratureRule< P1DivTestIntegrand< LHSDerived, RHSDerived, LHSMesh, RHSMesh > >

Deduction guide for QuadratureRule.

Parameters
integrand Expression to integrate.

Potential

Defined in Rodin/Variational/Potential.h

See declaration
template<class LHSType, class RHSDerived>
Potential(const LHSType& kernel, const FunctionBase<RHSDerived>& u) -> Potential< LHSType, FunctionBase< RHSDerived > >

CTAD for Potential.

Parameters
kernel Kernel of the nonlocal integral operator.
u Operand expression.

Potential

Defined in Rodin/Variational/Potential.h

See declaration
template<class LHSType, class RHSDerived, class FESType, ShapeFunctionSpaceType SpaceType>
Potential(const LHSType& kernel, const ShapeFunctionBase<ShapeFunction<RHSDerived, FESType, SpaceType>, FESType, SpaceType>& u) -> Potential< LHSType, ShapeFunctionBase< ShapeFunction< RHSDerived, FESType, SpaceType >, FESType, SpaceType > >

CTAD for Potential.

Parameters
kernel Kernel of the nonlocal integral operator.
u Operand expression.

Integral

Defined in Rodin/Variational/Potential.h

See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Dot<Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>, ShapeFunctionBase<RHSDerived, TestFES, TestSpace>>& integrand) -> Integral< Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for Integral.

Parameters
integrand Expression to integrate.

Integral

Defined in Rodin/Variational/Potential.h

See declaration
template<class KernelType, class LHSDerived, class TrialFES, class RHSDerived, class TestFES>
Integral(const Potential<KernelType, ShapeFunctionBase<LHSDerived, TrialFES, TrialSpace>>& lhs, const ShapeFunctionBase<RHSDerived, TestFES, TestSpace>& rhs) -> Integral< Dot< Potential< KernelType, ShapeFunctionBase< LHSDerived, TrialFES, TrialSpace > >, ShapeFunctionBase< RHSDerived, TestFES, TestSpace > > >

Deduction guide for Integral.

Parameters
lhs Left operand.
rhs Right operand.

template<class NestedDerived, class Number>
auto pow(const FunctionBase<NestedDerived>& f, Number exponent)

Defined in Rodin/Variational/Pow.h

Builds the pointwise power of a function expression.

Parameters
f Function operand.
exponent Exponent of the power.
Returns Pointwise power expression.

Problem

Defined in Rodin/Variational/Problem.h

See declaration
template<class U1, class U2, class U3, class... Us>
Problem(U1& u1, U2& u2, U3& u3, Us&... us) -> Problem< Math::LinearSystem< Math::SparseMatrix< typename FormLanguage::Mult< typename FormLanguage::Traits< typename FormLanguage::Traits< U1 >::FESType >::ScalarType, typename FormLanguage::Traits< typename FormLanguage::Traits< U2 >::FESType >::ScalarType >::Type >, Math::Vector< typename FormLanguage::Traits< typename FormLanguage::Traits< U2 >::FESType >::ScalarType > >, U1, U2, U3, Us... >

Deduction guide for Problem.

Parameters
u1 Trial shape functions defining the unknowns.
u2 Trial shape functions defining the unknowns.
u3 Trial shape functions defining the unknowns.
us Trial shape functions defining the unknowns.

ProblemBody

Defined in Rodin/Variational/ProblemBody.h

See declaration
template<class Scalar>
ProblemBody(const LocalBilinearFormIntegratorBase<Scalar>& pbo) -> ProblemBody< void, void, Scalar >

Deduction guide for ProblemBody.

Parameters
pbo Problem body supplying the operator terms.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LinearFormIntegratorBase<LHSScalar>& lfi, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
lfi Linear form integrator.
bfi Bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const GlobalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const GlobalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
lfis Linear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const LinearFormIntegratorBase<LHSScalar>& lfi, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
lfi Linear form integrator.
bfi Bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfis Bilinear form integrators.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
lbfis Local bilinear form integrators.
gbfi Global bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const FormLanguage::List<GlobalBilinearFormIntegratorBase<RHSScalar>>& gbfis)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
lbfis Local bilinear form integrators.
gbfis Global bilinear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& lbfi, const FormLanguage::List<GlobalBilinearFormIntegratorBase<RHSScalar>>& gbfis)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
lbfi Local bilinear form integrator.
gbfis Global bilinear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& lbfi, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
lbfi Local bilinear form integrator.
gbfi Global bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
bfis Bilinear form integrators.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const DirichletBCBase<RHSScalar>& dbc)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
dbc Dirichlet boundary condition.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
dbcs Dirichlet boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const PeriodicBCBase<RHSScalar>& pbc)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
pbc Periodic boundary condition.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
pbcs Periodic boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const DirichletBCBase<RHSScalar>& dbc)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfis Bilinear form integrators.
dbc Dirichlet boundary condition.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfis Bilinear form integrators.
dbcs Dirichlet boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& bfis, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfis Bilinear form integrators.
pbcs Periodic boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LocalBilinearFormIntegratorBase<RHSScalar>& lbfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lbfi Local bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<Operator, Vector, LHSScalar>& pb, const LocalBilinearFormIntegratorBase<RHSScalar>& lbfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lbfi Local bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const GlobalBilinearFormIntegratorBase<RHSScalar>& gbfi)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
gbfi Global bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lfis Linear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lfi Linear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<LinearFormIntegratorBase<RHSScalar>>& lfis)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
pb Problem body to extend.
lfis Linear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const DirichletBCBase<RHSScalar>& dbc)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
dbc Dirichlet boundary condition.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<DirichletBCBase<RHSScalar>>& dbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
dbcs Dirichlet boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const PeriodicBCBase<RHSScalar>& pbc)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
pbc Periodic boundary condition.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const BilinearFormBase<OperatorType>& bf)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
bf Preassembled bilinear form.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const FormLanguage::List<PeriodicBCBase<RHSScalar>>& pbcs)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
pbcs Periodic boundary conditions.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class LHSScalar>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const BilinearFormBase<OperatorType>& bf)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
bfi Bilinear form integrator.
bf Preassembled bilinear form.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class OperatorType, class RHSScalar>
auto operator+(const BilinearFormBase<OperatorType>& bf, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi)

Defined in Rodin/Variational/ProblemBody.h

Combines a bilinear form and a local bilinear form integrator.

Parameters
bf Assembled bilinear form.
bfi Local bilinear form integrator.
Returns Problem body containing both terms.

template<class OperatorType, class RHSScalar>
auto operator+(const BilinearFormBase<OperatorType>& bf, const DirichletBCBase<RHSScalar>& dbc)

Defined in Rodin/Variational/ProblemBody.h

Combines a preassembled BilinearForm with a DirichletBC into a ProblemBody.

Parameters
bf Bilinear form.
dbc Dirichlet boundary condition.
Returns Sum of the operands.

Enables expression chains such as: problem = preassembledBF + DirichletBC(u, g); where the BilinearForm has already been assembled and the Dirichlet boundary condition is added to constrain the problem.

Scalar value type.

template<class OperatorType, class RHSScalar>
auto operator-(const BilinearFormBase<OperatorType>& bf, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a linear integrator from a preassembled bilinear form.

Parameters
bf Preassembled bilinear form.
lfi Linear integrator whose negated expression is appended.
Returns Problem body owning copies of the supplied terms.

Scalar value type.

template<class OperatorType, class RHSScalar>
auto operator-(const FormLanguage::List<BilinearFormBase<OperatorType>>& bfs, const LinearFormIntegratorBase<RHSScalar>& lfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a linear integrator from preassembled bilinear forms.

Parameters
bfs Preassembled bilinear forms.
lfi Linear integrator whose negated expression is appended.
Returns Problem body owning copies of the supplied terms.

Scalar value type.

template<class LHSScalar, class OperatorType>
auto operator+(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const FormLanguage::List<BilinearFormBase<OperatorType>>& bfs)

Defined in Rodin/Variational/ProblemBody.h

Combines a local bilinear integrator with preassembled bilinear forms.

Parameters
bfi Local bilinear integrator.
bfs Preassembled bilinear forms.
Returns Problem body owning copies of the supplied terms.

Scalar value type.

template<class LHSScalar, class OperatorType>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const BilinearFormBase<OperatorType>& bf)

Defined in Rodin/Variational/ProblemBody.h

Combines a list of local bilinear form integrators with a preassembled BilinearForm into a ProblemBody.

Parameters
lbfis Local bilinear form integrators.
bf Bilinear form.
Returns Sum of the operands.

Enables expression chains such as: problem = Integral(u, v) - Integral(p, v) + preassembledBF - ...; where the first two Integral terms produce a List<LocalBFI> (via Sum) and the preassembled BilinearForm is added afterwards.

Scalar value type.

template<class LHSScalar, class VectorType>
auto operator-(const LocalBilinearFormIntegratorBase<LHSScalar>& bfi, const LinearFormBase<VectorType>& lf)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a preassembled LinearForm from a single local bilinear form integrator to create a ProblemBody.

Parameters
bfi Bilinear form integrator.
lf Linear form.
Returns Difference of the operands, or the negated operand for the unary overload.

Enables expression chains such as: problem = Integral(Grad(u), Grad(v)) - assembledLoadForm; where a single Integral term (LocalBFI) is combined with a preassembled LinearForm.

Scalar value type.

template<class LHSScalar, class VectorType>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSScalar>>& lbfis, const LinearFormBase<VectorType>& lf)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a preassembled LinearForm from a list of local bilinear form integrators to create a ProblemBody.

Parameters
lbfis Local bilinear form integrators.
lf Linear form.
Returns Difference of the operands, or the negated operand for the unary overload.

Enables expression chains such as: problem = Integral(u, v) - Integral(p, v) + Integral(p, q) - loadP0; where the Integral terms produce a List<LocalBFI> and the preassembled LinearForm is subtracted afterwards.

Scalar value type.

template<class OperatorType, class LHSScalar, class VectorType>
auto operator-(const ProblemBody<OperatorType, void, LHSScalar>& pb, const LinearFormBase<VectorType>& lf)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a preassembled LinearForm from a ProblemBody that has an OperatorType but no VectorType yet.

Parameters
pb Variational problem to operate on.
lf Linear form.
Returns Difference of the operands, or the negated operand for the unary overload.

Enables expression chains such as: problem = Integral(u, v) - Integral(p, v) + preassembledBF - loadP0; where the chain first produces ProblemBody<Op, void, S> (after adding the preassembled BF) and then the LinearForm introduces the VectorType.

Scalar value type.

template<class OperatorType, class VectorType, class LHSScalar>
auto operator-(const ProblemBody<OperatorType, VectorType, LHSScalar>& pb, const LinearFormBase<VectorType>& lf)

Defined in Rodin/Variational/ProblemBody.h

Subtracts a preassembled LinearForm from a ProblemBody that already carries a VectorType.

Parameters
pb Variational problem to operate on.
lf Linear form.
Returns Difference of the operands, or the negated operand for the unary overload.

The $ \mathrm{void} $ -vector overload above covers the case where the LinearForm is what introduces the vector; this one covers a body that already holds linear-form content, so that several preassembled forms can be reused in one chain: problem = preassembledBF + Integral(u, v) - Integral(f, v) - preassembledLF;

Scalar value type.

template<class Operator, class Vector, class Scalar>
auto operator-(const ProblemBody<Operator, Vector, Scalar>& pb, const BilinearFormBase<Operator>& bf)

Defined in Rodin/Variational/ProblemBody.h

Subtracts an owned snapshot of a preassembled bilinear form.

Parameters
pb Problem body to extend.
bf Preassembled bilinear form whose negated snapshot is appended.
Returns Extended problem body owning the negated bilinear form.

template<class Operator, class Vector, class Scalar>
auto operator+(const ProblemBody<Operator, Vector, Scalar>& pb, const LinearFormBase<Vector>& lf)

Defined in Rodin/Variational/ProblemBody.h

Adds a preassembled linear form to the residual, hence negates its load.

Parameters
pb Problem body to extend.
lf Preassembled linear form whose negated load snapshot is appended.
Returns Extended problem body owning the negated load.

template<class LHSScalar, class RHSScalar>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSScalar>>& lfis, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi)

Defined in Rodin/Variational/ProblemBody.h

Combines linear integrators with a local bilinear integrator.

Parameters
lfis Linear integrators.
bfi Local bilinear integrator.
Returns Problem body owning copies of the supplied terms.

Scalar value type.

template<class LHSScalar, class RHSScalar>
auto operator-(const FormLanguage::List<LinearFormIntegratorBase<LHSScalar>>& lfis, const LocalBilinearFormIntegratorBase<RHSScalar>& bfi)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
lfis Linear form integrators.
bfi Bilinear form integrator.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator+(const ProblemBody<Operator, Vector, LHSScalar>& pb, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSScalar>>& bfis)

Defined in Rodin/Variational/ProblemBody.h

Adds variational terms to construct a problem body.

Parameters
pb Problem body to extend.
bfis Bilinear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

template<class Operator, class Vector, class LHSScalar, class RHSScalar>
auto operator-(const ProblemBody<Operator, Vector, LHSScalar>& pb, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSScalar>>& bfis)

Defined in Rodin/Variational/ProblemBody.h

Subtracts variational terms to construct a problem body.

Parameters
pb Problem body to extend.
bfis Bilinear form integrators.
Returns Problem body owning the supplied terms with their algebraic signs.

Scalar value type.

Re

Defined in Rodin/Variational/Re.h

See declaration
template<class NestedDerived>
Re(const FunctionBase<NestedDerived>& f) -> Re< FunctionBase< NestedDerived > >

CTAD for Re.

Parameters
f Complex-valued function operand

RealFunction

Defined in Rodin/Variational/RealFunction.h

See declaration
template<class Derived>
RealFunction(const FunctionBase<Derived>& nested) -> RealFunction< FunctionBase< Derived > >

CTAD for RealFunction.

Parameters
nested Real-valued expression to clone

RealFunction

Defined in Rodin/Variational/RealFunction.h

See declaration
template<class Derived>
RealFunction(const RealFunctionBase<Derived>& nested) -> RealFunction< FunctionBase< typename RealFunctionBase< Derived >::Parent > >

CTAD for a typed real-function base.

Parameters
nested Real-valued expression to clone.

RealFunction

Defined in Rodin/Variational/RealFunction.h

See declaration
RealFunction(Real x) -> RealFunction< Real >

CTAD for RealFunction.

Parameters
x Constant scalar value

RealFunction

Defined in Rodin/Variational/RealFunction.h

See declaration
RealFunction(Integer x) -> RealFunction< Integer >

CTAD for integer constants.

Parameters
x Constant integer value

RealFunction

Defined in Rodin/Variational/RealFunction.h

See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_v<F, const Geometry::Point&>>>
RealFunction(F f) -> RealFunction< F >

CTAD for RealFunction.

Parameters
f Callable returning a Real from a Geometry::Point

Sin

Defined in Rodin/Variational/Sine.h

See declaration
template<class NestedDerived>
Sin(const FunctionBase<NestedDerived>& v) -> Sin< FunctionBase< NestedDerived > >

Deduction guide for Sin.

Parameters
v Function to apply sine to

template<class NestedDerived>
auto sin(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Sine.h

Helper function to construct objects of type Sin.

Parameters
f Function operand.
Returns Pointwise sine expression.

Sinh

Defined in Rodin/Variational/Sinh.h

See declaration
template<class NestedDerived>
Sinh(const FunctionBase<NestedDerived>& v) -> Sinh< FunctionBase< NestedDerived > >

Deduction guide for Sinh.

Parameters
v Function to apply sinh to

template<class NestedDerived>
auto sinh(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Sinh.h

Helper function to construct objects of type Sinh.

Parameters
f Function operand.
Returns Pointwise hyperbolic-sine expression.

Sqrt

Defined in Rodin/Variational/Sqrt.h

See declaration
template<class NestedDerived>
Sqrt(const FunctionBase<NestedDerived>& v) -> Sqrt< FunctionBase< NestedDerived > >

Deduction guide for Sqrt.

Parameters
v Function to take square root of (must be non-negative)

template<class NestedDerived>
auto sqrt(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Sqrt.h

Helper function to construct objects of type Sqrt.

Parameters
f Function operand.
Returns Pointwise square-root expression.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSDerived, class RHSDerived>
Sum(const FunctionBase<LHSDerived>& lhs, const FunctionBase<RHSDerived>& rhs) -> Sum< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Deduction guide for function sum.

Parameters
lhs Left operand.
rhs Right operand.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
Sum(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) -> Sum< ShapeFunctionBase< LHSDerived, FES, Space >, ShapeFunctionBase< RHSDerived, FES, Space > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSDerived, class RHSDerived, class FES, ShapeFunctionSpaceType Space>
auto operator+(const ShapeFunctionBase<LHSDerived, FES, Space>& lhs, const ShapeFunctionBase<RHSDerived, FES, Space>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two shape function expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LinearFormIntegratorBase<LHSNumber>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< LinearFormIntegratorBase< LHSNumber >, LinearFormIntegratorBase< RHSNumber > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const LinearFormIntegratorBase<LHSNumber>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two linear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< LinearFormIntegratorBase< LHSNumber >, FormLanguage::List< LinearFormIntegratorBase< RHSNumber > > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const LinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two linear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >, LinearFormIntegratorBase< RHSNumber > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const LinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two linear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< FormLanguage::List< LinearFormIntegratorBase< LHSNumber > >, FormLanguage::List< LinearFormIntegratorBase< RHSNumber > > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two linear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< LocalBilinearFormIntegratorBase< LHSNumber >, LocalBilinearFormIntegratorBase< RHSNumber > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two bilinear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< LocalBilinearFormIntegratorBase< LHSNumber >, FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const LocalBilinearFormIntegratorBase<LHSNumber>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two bilinear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) -> Sum< FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >, LocalBilinearFormIntegratorBase< RHSNumber > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const LocalBilinearFormIntegratorBase<RHSNumber>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two bilinear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class LHSNumber, class RHSNumber>
Sum(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) -> Sum< FormLanguage::List< LocalBilinearFormIntegratorBase< LHSNumber > >, FormLanguage::List< LocalBilinearFormIntegratorBase< RHSNumber > > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class LHSNumber, class RHSNumber>
auto operator+(const FormLanguage::List<LocalBilinearFormIntegratorBase<LHSNumber>>& lhs, const FormLanguage::List<LocalBilinearFormIntegratorBase<RHSNumber>>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two bilinear form integrators.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Sum

Defined in Rodin/Variational/Sum.h

See declaration
template<class Operator>
Sum(const BilinearFormBase<Operator>& lhs, const BilinearFormBase<Operator>& rhs) -> Sum< BilinearFormBase< Operator >, BilinearFormBase< Operator > >

Deduction guide for Sum.

Parameters
lhs Left operand.
rhs Right operand.

template<class Operator>
auto operator+(const BilinearFormBase<Operator>& lhs, const BilinearFormBase<Operator>& rhs) constexpr

Defined in Rodin/Variational/Sum.h

Sum of two expressions.

Parameters
lhs Left operand.
rhs Right operand.
Returns Sum of the operands.

Tan

Defined in Rodin/Variational/Tangent.h

See declaration
template<class NestedDerived>
Tan(const FunctionBase<NestedDerived>& v) -> Tan< FunctionBase< NestedDerived > >

Deduction guide for Tan.

Parameters
v Function to apply tangent to

template<class NestedDerived>
auto tan(const FunctionBase<NestedDerived>& f)

Defined in Rodin/Variational/Tangent.h

Builds the pointwise tangent of a function expression.

Parameters
f Function operand.
Returns Pointwise tangent expression.

TensorFunction

Defined in Rodin/Variational/TensorFunction.h

See declaration
template<class Value>
TensorFunction(Value value) -> TensorFunction< Value >

Deduces the matrix space or coefficient type from constructor arguments.

Parameters
value Value to store or assign.

TestFunction

Defined in Rodin/Variational/TestFunction.h

See declaration
template<class FES>
TestFunction(const FES& fes) -> TestFunction< FES >

Deduction guide for TestFunction.

Parameters
fes Finite element space

Allows automatic type deduction when constructing a TestFunction:

P1 Vh(mesh);
TestFunction v(Vh);  // Type deduced as TestFunction<P1>

Trace

Defined in Rodin/Variational/Trace.h

See declaration
template<class NestedDerived>
Trace(const FunctionBase<NestedDerived>& operand) -> Trace< FunctionBase< NestedDerived > >

Deduction guide for Trace.

Parameters
operand Operand expression.

Trace

Defined in Rodin/Variational/Trace.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Trace(const ShapeFunctionBase<NestedDerived, FES, Space>& operand) -> Trace< ShapeFunctionBase< NestedDerived, FES, Space > >

Deduction guide for Trace.

Parameters
operand Operand expression.

Transpose

Defined in Rodin/Variational/Transpose.h

See declaration
template<class NestedDerived>
Transpose(const FunctionBase<NestedDerived>& m) -> Transpose< FunctionBase< NestedDerived > >

Deduction guide for function transpose.

Parameters
m Matrix function to transpose

Transpose

Defined in Rodin/Variational/Transpose.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
Transpose(const ShapeFunctionBase<NestedDerived, FES, Space>& m) -> Transpose< ShapeFunctionBase< NestedDerived, FES, Space > >

Deduction guide for ShapeFunction transpose.

Parameters
m Matrix function to transpose

TrialFunction

Defined in Rodin/Variational/TrialFunction.h

See declaration
template<class FES>
TrialFunction(const FES& fes) -> TrialFunction< GridFunction< FES, Math::Vector< typename FormLanguage::Traits< FES >::ScalarType > >, FES >

Deduction guide for TrialFunction.

Parameters
fes Finite element space

Allows automatic type deduction when constructing a TrialFunction:

P1 Uh(mesh);
TrialFunction u(Uh);  // Type deduced automatically

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class NestedDerived>
UnaryMinus(const FunctionBase<NestedDerived>& op) -> UnaryMinus< FunctionBase< NestedDerived > >

Deduction guide for UnaryMinus of FunctionBase.

Parameters
op Operand expression.

template<class NestedDerived>
auto operator-(const FunctionBase<NestedDerived>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a function.

Parameters
op Function to negate
Returns Negated function

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
UnaryMinus(const ShapeFunctionBase<NestedDerived, FES, Space>& op) -> UnaryMinus< ShapeFunctionBase< NestedDerived, FES, Space > >

Deduction guide for UnaryMinus of ShapeFunctionBase.

Parameters
op Operand expression.

template<class NestedDerived, class FES, ShapeFunctionSpaceType Space>
auto operator-(const ShapeFunctionBase<NestedDerived, FES, Space>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a shape function.

Parameters
op Shape function to negate
Returns Negated shape function

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const LinearFormIntegratorBase<Number>& op) -> UnaryMinus< LinearFormIntegratorBase< Number > >

Deduction guide for UnaryMinus of LinearFormIntegratorBase.

Parameters
op Operand expression.

template<class Number>
UnaryMinus<LinearFormIntegratorBase<Number>> operator-(const LinearFormIntegratorBase<Number>& lfi)

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a linear form integrator.

Parameters
lfi Linear form integrator to negate
Returns Negated linear form integrator

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<LinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< LinearFormIntegratorBase< Number > > >

Deduction guide for UnaryMinus of List<LinearFormIntegratorBase>.

Parameters
op Operand expression.

template<class Number>
UnaryMinus<FormLanguage::List<LinearFormIntegratorBase<Number>>> operator-(const FormLanguage::List<LinearFormIntegratorBase<Number>>& op)

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a list of linear form integrators.

Parameters
op List to negate
Returns Negated integrator list

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const LocalBilinearFormIntegratorBase<Number>& op) -> UnaryMinus< LocalBilinearFormIntegratorBase< Number > >

Deduction guide for UnaryMinus of LocalBilinearFormIntegratorBase.

Parameters
op Operand expression.

template<class Number>
auto operator-(const LocalBilinearFormIntegratorBase<Number>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a bilinear form integrator.

Parameters
op Bilinear form integrator to negate
Returns Negated bilinear form integrator

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< LocalBilinearFormIntegratorBase< Number > > >

Deduction guide for UnaryMinus of List<LocalBilinearFormIntegratorBase>.

Parameters
op Operand expression.

template<class Number>
auto operator-(const FormLanguage::List<LocalBilinearFormIntegratorBase<Number>>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a list of bilinear form integrators.

Parameters
op List to negate
Returns Negated integrator list

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const GlobalBilinearFormIntegratorBase<Number>& op) -> UnaryMinus< GlobalBilinearFormIntegratorBase< Number > >

Deduction guide for UnaryMinus of GlobalBilinearFormIntegratorBase.

Parameters
op Operand expression.

template<class Number>
auto operator-(const GlobalBilinearFormIntegratorBase<Number>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a bilinear form integrator.

Parameters
op Bilinear form integrator to negate
Returns Negated bilinear form integrator

UnaryMinus

Defined in Rodin/Variational/UnaryMinus.h

See declaration
template<class Number>
UnaryMinus(const FormLanguage::List<GlobalBilinearFormIntegratorBase<Number>>& op) -> UnaryMinus< FormLanguage::List< GlobalBilinearFormIntegratorBase< Number > > >

Deduction guide for UnaryMinus of List<GlobalBilinearFormIntegratorBase>.

Parameters
op Operand expression.

template<class Number>
auto operator-(const FormLanguage::List<GlobalBilinearFormIntegratorBase<Number>>& op) constexpr

Defined in Rodin/Variational/UnaryMinus.h

Applies unary minus to a list of bilinear form integrators.

Parameters
op List to negate
Returns Negated integrator list

VectorFunction

Defined in Rodin/Variational/VectorFunction.h

See declaration
template<class Scalar>
VectorFunction(const Math::Vector<Scalar>& v) -> VectorFunction< Math::Vector< Scalar > >

CTAD for dense-vector constants.

Parameters
v The vector values

VectorFunction

Defined in Rodin/Variational/VectorFunction.h

See declaration
template<class Scalar>
VectorFunction(const Eigen::VectorX<Scalar>& v) -> VectorFunction< Math::Vector< Scalar > >

CTAD for native Eigen dense-vector constants.

Template parameters
Scalar Vector scalar type.
Parameters
v Vector borrowed when an lvalue and retained when a temporary.

VectorFunction

Defined in Rodin/Variational/VectorFunction.h

See declaration
template<class V, class... Values>
VectorFunction(const V& v, const Values&... values) -> VectorFunction< V, Values... >

CTAD for component-wise vector functions.

Parameters
v First component source
values Parameter pack of values

VectorFunction

Defined in Rodin/Variational/VectorFunction.h

See declaration
template<class F, typename = std::enable_if_t<std::is_invocable_v<F, const Geometry::Point&>>>
VectorFunction(size_t vdim, F f) -> VectorFunction< F >

CTAD for callable vector functions.

Parameters
vdim Vector dimension
f Callable returning a vector value

Zero

Defined in Rodin/Variational/Zero.h

See declaration
Zero() -> Zero< Real >

CTAD (Class Template Argument Deduction) for scalar Zero.

Deduces Zero<Real> from Zero()

Zero

Defined in Rodin/Variational/Zero.h

See declaration
Zero(size_t vdim) -> Zero< Math::SpatialVector< Real > >

CTAD for vector Zero.

Parameters
vdim Number of components in the value range.

Deduces Zero<Math::SpatialVector<Real>> from Zero(size_t)

Variable documentation

template<class LHSDerived, class RHSDerived>
Rodin::Variational::AND< BooleanFunctionBase< LHSDerived >, BooleanFunctionBase< RHSDerived > >

Defined in Rodin/Variational/AND.h

Deduction guide for AND.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::EQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/EQ.h

Deduction guide for EQ.

static const ShapeFunctionSpaceType Rodin::Variational::TrialSpace constexpr

Defined in Rodin/Variational/ForwardDecls.h

Shorthand variable for ShapeFunctionSpaceType::Trial.

static const ShapeFunctionSpaceType Rodin::Variational::TestSpace constexpr

Defined in Rodin/Variational/ForwardDecls.h

Shorthand variable for ShapeFunctionSpaceType::Test.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::GEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/GEQ.h

CTAD for GEQ.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::GT< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/GT.h

CTAD for GT.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::LEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/LEQ.h

Deduction guide for LEQ.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::LT< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/LT.h

CTAD for LT.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::NEQ< FunctionBase< LHSDerived >, FunctionBase< RHSDerived > >

Defined in Rodin/Variational/NEQ.h

Deduction guide for NEQ.

template<class LHSDerived, class RHSDerived>
Rodin::Variational::OR< BooleanFunctionBase< LHSDerived >, BooleanFunctionBase< RHSDerived > >

Defined in Rodin/Variational/OR.h

Deduction guide for OR.