| ▼NDune | |
| ►NACFem | A namespace encapsulating everything defined in our dune-acfem project |
| ►NBoundaryIndicator | |
| CAreProperOperands | |
| CBoundaryIdIndicator | Apply to boundary segments which carry the respective id |
| CBoundaryIndicator | Boundary indicators need to inherit this tag-class in order to signal that they are boundary indicators |
| CComplement | Turn any boundary-indicator into its complement |
| CIndicatorTraits | Paraphrase isOne and isZero to indicator function talk |
| CIntersectionIndicator | Intersection of two indicators, apply iff both apply |
| CIsIndicator | TrueType if T is a BoundaryIndicator |
| CUnionIndicator | Union of two indicators, apply to the union of both boundary parts |
| ►NExpressions | |
| ►NExamineImpl | |
| CDepthFunctor | |
| ►CFunctorFactory | |
| CAccumulate | Just accumulate all values, F must accept the expression as first template parameter |
| CRecurse | Feed the accumulated values for the operands back into F |
| ►Nimpl | |
| CEvaluateSubExpression | Operation functor for transform() which evaluates all contained sub-expressions |
| ►NSums | |
| CAddNodesHelper | |
| CAddNodesHelper< OptimizeTag, Left, Right, std::enable_if_t< FunctorHas< IsMinusOperation, typename Left::Sign >::value > > | |
| CIsExplodeOperand | |
| CProcessExplodeHelper | |
| CReplaceByMinimum | |
| CAreRuntimeEqual | FalseType by default |
| CAreRuntimeEqual< T1, T2, std::enable_if_t<(!IsSubExpressionExpression< T1 >::value &&!IsSubExpressionExpression< T2 >::value &&(!IsRuntimeEqual< T2 >::value||!IsRuntimeEqual< T1 >::value))> > | Decide whether to consider object of the given types as equal at runtime, although their actual value may not be constant |
| CAreRuntimeEqual< T1, T2, std::enable_if_t<(IsExponentiationExpression< T1 >::value &&IsExponentiationExpression< T2 >::value &&std::is_same< BaseOfPower< T1 >, BaseOfPower< T2 > >::value &&ExponentOfPower< T1 >::value==ExponentOfPower< T2 >::value)> > | Identify the various flavours of drawing powers |
| CAreRuntimeEqual< T1, T2, std::enable_if_t<(IsSubExpressionExpression< T1 >::value &&IsSubExpressionExpression< T2 >::value)> > | FalseType by default |
| CClosureTraits | Provide the type ExpressionType for non-closure expressions |
| CClosureTraits< T, std::enable_if_t< IsClosure< T >::value > > | Provide the type ExpressionType for closure expressions |
| CCommonSubExpressionCascade | Wrap tuple of subexpressions with constant references to sub-expressions of lower levels |
| CCommonSubExpressionCascade< Traits, std::tuple< std::tuple< SExp... >, PrevSExp, SExpRest... > > | Recurse to less deep subexpressions |
| CCommonSubExpressionCascade< Traits, std::tuple< std::tuple<> > > | Terminal in template recursion |
| CContainsPlaceholders | Yields std::true_type if the expression E contains placeholders |
| CDefaultTerminalPredicate | |
| CDenseStorage | A traits class which provides a type suitable to store the values of the given expression T and any expressions of "similar" type |
| CDontOperate | Operation functor which does not operate and collapes the entire expression to a dummy return value of int 0 |
| CExpressionSign | A class mainting the sign of an expression during operations |
| CExtractDataDefaultFunctor | Default pack-data functor |
| CInjectionTraits | Traits class in order to inject general object into the expression chain in a controlled manner |
| CIsBasicRuntimeEqual< T, std::enable_if_t< IsSubExpressionExpression< T >::value > > | SubExpressionOperation expressions qualify for IsRuntimeEqual if the contained sub-expression qualifies |
| CIsBinaryExpression | TrueType if T is an expression of arity 2, otherwise FalseType |
| CIsClosure | An expression closure is a wrapper class which wraps an expression in order to interface to other existing interface |
| CIsClosure< T, std::enable_if_t<!IsDecay< T >::value > > | Forward references to the real traits class |
| CIsClosure< T, std::enable_if_t<(IsDecay< T >::value &&IsPDEModel< T >::value &&IsUnaryExpression< T >::value &&!IsSelfExpression< T >::value)> > | Identify the expression closure |
| CIsClosure< Tensor::TensorResult< T > > | Mark TensorResult as a closure expression |
| CIsCSECascade | |
| CIsCSECascade< CommonSubExpressionCascade< Traits, DepthTuple > > | Identity CommonSubExpressionCascade objects |
| CIsCSECascade< T, std::enable_if_t<!IsDecay< T >::value > > | |
| CIsExpression< T, VoidType< void, decltype(std::decay_t< T >::arity()) > > | Identify something conforming to the expression interface |
| CIsExpressionOfArity | TrueType if T is an expression of arity N, otherwise FalseType |
| CIsMatchingSubExpression | |
| CIsMatchingSubExpression< T, SExp, std::enable_if_t<(IsSubExpressionExpression< T >::value &&AreRuntimeEqual< Operand< 1, T >, Operand< 1, SExp > >::value)> > | Needed to replace references to sub-expression during copy and move construction of the CommonSubExpressionCascade |
| CIsOperand | |
| CIsOperand< T, std::enable_if_t<!IsDecay< T >::value > > | |
| CIsOperand< T, std::enable_if_t<(IsExpression< T >::value &&IsDecay< T >::value)> > | |
| CIsSelfExpression | Identify self-contained terminals, see SelfExpression |
| CIsUnaryExpression | TrueType if T is an expression of arity 1, otherwise FalseType |
| COperate | Default operation functor for transform |
| COperateClone | Operation functor for transform() |
| COperateDecay | Operation functor for transform() |
| COperationPair | Collect sign, operation and data-types of the operands for a binary operation |
| COperationPair< S, F, MPL::TypeTuple< TreeData0... >, TreeData1, OptimizeTag > | An operations pair for collecting tuples of operands subject to the same operation as left operand with a single right operand |
| COperationPair< S, F, TreeData0, MPL::TypeTuple< TreeData1... >, OptimizeTag > | An operations pair for collecting tuples of operands subject to the same operation as right operand with a single left operand |
| COptimizeTag | Optimization pattern disambiguation struct |
| CReplaceByOperand | Replace matching expressions by their operand no |
| CReplaceDefaultIgnore | |
| CReplaceFunctor | Replace all expression operands of type T where When<T, From> is std::true_type by an instance of To |
| CSameOperandFunctors | @interal SFINAE default for examining the functors of operands when we do not know whether T has sufficiently many operands |
| CSameOperandFunctors< T, std::enable_if_t< IsUnaryExpression< T >::value > > | |
| CSameOperandFunctors< T, std::enable_if_t<(IsBinaryExpression< T >::value &&std::is_same< Functor< Operand< 0, T > >, Functor< Operand< 1, T > > >::value)> > | |
| CSameOperandFunctors< T, std::enable_if_t<(IsExpression< T >::value &&Arity< T >::value > 2)> > | |
| CSelfExpression | Terminals may derive from this class to express that they are expressions |
| CSimpleReplaceFunctor | Variant o ReplaceFunctor where When may be a simple unary IsSomething trait |
| CTraitsOfTags | Deduce ExpressionTraits from tag-class overrides |
| CTraverseFunctor | |
| CTreeData | Collect type, sign and the position in an expression of one operand |
| ►NGridFunction | |
| CBindableTensorFunction | Wrap a tensor into a Fem::BindableGridFunction |
| CElementMeasurePlaceholder | A placeholder tensor which evaluates to the measure of the element after binding it |
| CHasBind< Placeholder, VoidType< decltype(std::declval< Placeholder >().bind(std::declval< typename std::decay_t< Placeholder >::EntityType >()))> > | |
| CHasGridPartMethod | |
| CHasGridPartMethod< T, VoidType< decltype(std::declval< T >().gridPart())> > | TrueType if a T has a gridPart() method |
| CHasIndeterminateSetValue< Placeholder, VoidType< decltype(std::declval< Placeholder >().setValue(std::declval< typename std::decay_t< Placeholder >::IndeterminateType >()))> > | |
| CHasRangeType | |
| CHasRangeType< T, VoidType< typename std::decay_t< T >::RangeType > > | TrueType if T provides a RangeType |
| CHasRegularity | |
| CHasRegularity< BindableTensorFunction< Expr, GridPart, AutoDiffOrder, IndeterminateId >, AtLeastRequestedOrder, AtMostRequestedOrder > | Evaluate to TrueType if the given BindableTensorFunction fufils the regularity requirements given by the "box
constaints" AtLeastRequestedOrder and AtMostRequestedOrder |
| CHasSetValue< Placeholder, VoidType< decltype(std::declval< Placeholder >().setValue(std::declval< PlaceholderQuadraturePoint< typename std::decay_t< Placeholder >::DomainType > >())) > > | |
| CHasUnbind< Placeholder, VoidType< decltype(std::declval< Placeholder >().unbind())> > | |
| CIsConstLocalFunction | |
| CIsConstLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | |
| CIsConstLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_same< T, Fem::ConstLocalFunction< typename T::GridFunctionType > >{})> > | TrueType if a T can be wrapped into a Fem::ConstLocalFunction |
| CIsConstLocalFunctionOperand | TrueType if T can be passed through constLocalFunction() |
| CIsLocalFunction | |
| CIsLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | @intenal Forward to decay_t<> |
| CIsLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_same< void, decltype(std::declval< T >().bind(std::declval< typename T::EntityType >()))>{} &&std::is_same< void, decltype(std::declval< T >().evaluate(std::declval< PlaceholderQuadraturePoint< typename T::DomainType > >(), std::declval< typename T::RangeType & >()))>{})> > | Identify a Fem::LocalFunction |
| CIsLocalFunctionPlaceholder | Std::true_type if T is a LocalFunctionPlaceholder |
| CIsTensorFunction | |
| CIsTensorFunction< BindableTensorFunction< Expr, GridPart, AutoDiffOrder, IndeterminateId > > | Identify a BindableTensorFunction |
| CIsTensorFunction< T & > | |
| CIsTensorFunction< T && > | |
| CIsWrappableByConstLocalFunction | |
| CIsWrappableByConstLocalFunction< T, std::enable_if_t<!IsDecay< T >{}> > | |
| CIsWrappableByConstLocalFunction< T, std::enable_if_t<(IsDecay< T >{} &&std::is_base_of< Fem::HasLocalFunction, T >{})> > | TrueType if a T can be wrapped into a Fem::ConstLocalFunction |
| CLocalFunctionPlaceholder | A placeholder tensor which wraps a Dune::Fem LocalFunction |
| CModelDirichletValues | An adapter class which takes any ACFem-PDE model and extracts its Dirichlet values as a BoundarySupportedFunction |
| CPromoteAllFunctionOperands | |
| CPromoteFunctionOperands | |
| CPromoteTensorOperands | |
| ►NLinearFunctional | |
| CBinaryLinearFunctionalExpression | The one and only one binary expression |
| CDiracDistribution | Dirac-distribution |
| CDofStorageFunctional | A functional which inherits from a proper discrete function |
| CLinearFunctional | Light-weight base class for all linear functionals |
| COperatorFunctional | Convert any operator into a functional by fixing |
| CUnaryLinearFunctionalExpression< MinusOperation, T > | The one and only one unary expression |
| CZeroFunctional | The zero functional |
| ►NModelIntrospection | Deduce methods and call-signatures from an implemented model |
| CArgumentMask | Integral constant holding an argument mask |
| CIsModel< Model, std::enable_if_t<(IsDecay< Model >::value &&std::is_base_of< ModelBase< typename Model::DomainFunctionSpaceType, typename Model::RangeFunctionSpaceType >, Model >::value)> > | Std::true_type if Model is derived from ModelBase |
| ►CTraits< Model, std::enable_if_t< IsModel< Model >::value &&IsDecay< Model >::value > > | Traits class extracting structural information from a given PDE-model information |
| CExistsFunctor | Helper functor for global property |
| CIsAffineLinearFunctor | Helper functor for global property |
| CIsLinearFunctor | Helper functor for global property |
| CIsLoadFunctor | Helper functor for global property |
| CIsPiecewiseConstantFunctor | Helper functor for global property |
| ►NParameter | |
| CGeneric | A placeholder tensor which can be initialized in particular by a Fem::Parameter value |
| ►NPDEModel | |
| CApplyOperation | Apply a model to a function |
| CBinaryModelExpression< SMultiplyOperation, Left, Right, IndexSequence< tag... >, std::enable_if_t<(IsTensor< Left >::value &&TensorTraits< Left >::rank==0 &&IsPDEModel< Right >::value)> > | Binary model expression for S-multiplication with tensors |
| CBinaryModelExpression< SMultiplyOperation, Left, Right, IndexSequence< tag... >, std::enable_if_t<(IsWrappableByConstLocalFunction< Left >::value &&std::decay_t< Left >::FunctionSpaceType::dimRange==1 &&IsPDEModel< Right >::value)> > | Binary model expression for S-multiplication with functions |
| CBinaryModelMethods< ApplyOperation< L2LoadFlavour >, Model, Function > | Call the fluxDivergence inside the source() method and do not provide a flux() or fluxDivergence() method |
| CBinaryModelMethods< ApplyOperation< RitzLoadFlavour >, Model, Function > | Just provide all methods implemented by the model |
| CBulkLoadFunctionModel | Wrap an existing GridFunction into a model which only conatains this ModelConstituent |
| CClosureOperation | Augment the call signature of the methods listed in MethodTags by the call-signature indicated by the bit-masks in ClosureCallSignatures |
| CCropOperation | Remove all methods which are not listed in MethodTags |
| CDeformationTensorModel | Define the a model where the flux-part is formed from the symmetric gradient |
| CDirichletIndicator | A wrapper which constructs from the given model a Dirichlet boundary indicator, using Model::classifyBoundary |
| CDivergenceLoadModel | For a given grid-function define a model implementing the weak divergence |
| CDivergenceModel | A divergence model, for example to implement divergence constraints |
| CFluidSelfTransportModel | Define a model for the "Navier-Stokes" non-lineariry |
| CGradientLoadModel | For a given grid-function define a model implementing the weak gradient |
| CGradientModel | A gradient model, for example to implement gradient constraints |
| CIncompressibleSelfTransportModel | Define a model for the "Navier-Stokes" non-lineariry |
| CIncompressibleTransportModel | Define a model for an advection term with a divergence-free velocity field |
| CLaplacianModel | Define a simple Laplacian-model, given function-space and grid-part |
| CMassModel | Define a simple mass-model, given function-space and grid-part |
| CMeanCurvatureModel | Define a mean-curvature model for graphs and level-sets |
| CModelFacade | A class defining the "closure" type of all supported model-method and method-call-signatures |
| CModelMethod | Implement the method specified by tag with the signature defined by OuterArgSeq |
| CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, flux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< flux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, fluxDivergence, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< fluxDivergence >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedDirichlet, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedDirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedRobinFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedRobinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSingularFlux, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSingularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, linearizedSource, IndexSequence< LinArgsIdx... >, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< linearizedSource >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, ModelIntrospection::dirichlet, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< ModelIntrospection::dirichlet >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, robinFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< robinFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, singularFlux, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< singularFlux >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t< Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CModelMethod< Model, F, source, IndexSequence<>, IndexSequence< pointIndex, OuterArgsIdx... >, IndexSequence< InnerArgsIdx... >, std::enable_if_t<!Traits< Model >::template HasMethod< source >::value > > | Implement the method specified by tag with the signature defined by OuterArgSeq. |
| CNeumannBoundaryModel | A Neumann-boundary model |
| CNitscheDirichletBoundaryModel | This model constructs from a given other model weak Dirichlet conditions as first introduced by [2] |
| CP_LaplacianModel | The p-Laplacian-model |
| CP_MassModel | A simplistic non-linear example |
| CRangeTensorTraits | TensorTraits for the RangeType of a model, keeping scalar decay of 1d vectors into account |
| CRobinBoundaryModel | A (homogeneous) Robin-boundary model |
| CRobinIndicator | A wrapper which constructs from the given model a Robin boundary indicator, using Model::classifyBoundary |
| CSymmetricModel | Tag structure identifying symmetric models |
| CTransportModel | Define a model for an advection term |
| CUnaryModelExpression | General unary model expression template |
| CUnaryModelExpression< F, Model, IndexSequence< tag... >, Signatures > | Index-pack expansion helper and actual implementation |
| CWeakDivergenceLoadModel | For a given grid-function define a model implementing the weak divergence |
| CZeroModel | Define a simple zero model to optimize expression templates |
| ►NTensor | |
| ►NOptimization | |
| ►NAssociativity | |
| CIsLeftAssociativeProduct | Check for A*(B*C) -> (A*B)*C |
| CIsLeftAssociativeProductFinal | Check for A*(B*C) -> (A*B)*C |
| CIsRightAssociativeProduct | Check for (A*B)*C -> A*(B*C) |
| CLeftAssociatedTypeHelper | TrueType is the operation can be optimized by associating the double product left, i.e |
| ►NDistributivity | |
| ►NLeft | |
| CCollectOperands | |
| CCollectOperands< T, PrevOps, std::enable_if_t<!IsPositiveTreeNodeV< T > > > | |
| CFactorOutHelper | |
| CFactorOutHelper< MPL::TypeTuple< Scalars... >, MPL::TypeTuple< NonScalars... >, MPL::TypeTuple< Done... > > | |
| CFactorOutHelper< MPL::TypeTuple< Todo... >, void, void > | |
| CFactorOutHelper< void, MPL::TypeTuple< Todo... >, void > | Variant where we know that Todo does not contain scalar factor tuples |
| CFactorOutNonScalar | |
| CFactorOutNonScalar< T0, MPL::TypeTuple<>, MinusOperands > | |
| CFactorOutScalar | |
| CFactorOutScalar< MPL::TypeTuple< OperationPair< MinusFunctor, ScalarEinsumFunctor, Node0, Node1, Tag >, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t< MPL::HasMatchingTypeV< LeftFactor, Node0, Einsum::Unequal > > > | |
| CFactorOutScalar< MPL::TypeTuple< OperationPair< PlusFunctor, ScalarEinsumFunctor, Node0, Node1, Tag >, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t< MPL::HasMatchingTypeV< LeftFactor, Node0, Einsum::Unequal > > > | |
| CFactorOutScalar< MPL::TypeTuple< T0, T... >, LeftFactor, PlusOperands, MinusOperands, Rem, std::enable_if_t<!MPL::HasMatchingTypeV< LeftFactor, typename T0::TreeNode0, Einsum::Unequal > > > | |
| CFactorOutScalar< MPL::TypeTuple<>, LeftFactor, MPL::TypeTuple<>, MinusOperands, Rem > | |
| CFactorOutScalar< MPL::TypeTuple<>, LeftFactor, PlusOperands, MinusOperands, Rem > | |
| CFactorSwap | |
| CFactorSwap< A, B, std::enable_if_t<(!HasEinsumFunctorV< A > &&HasEinsumFunctorV< B >)> > | |
| CFactorSwap< A, B, std::enable_if_t<(HasEinsumFunctorV< A >==HasEinsumFunctorV< B > &&LexCompareProductOperationsV< typename A::FunctorType, typename B::FunctorType > > 0)> > | |
| CNonScalarRecursion< OperationPair< Sign, F, TreeData0, MPL::TypeTuple< TreeData1... >, Tag > > | |
| CProcessNonScalars< MPL::TypeTuple< T0 >, void > | |
| CProcessNonScalars< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t< AreMatchingNonScalarsV< Factor, T0 > > > | |
| CProcessNonScalars< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t<!AreMatchingNonScalarsV< Factor, T0 > > > | |
| CProcessNonScalars< MPL::TypeTuple< T0, T1, T... >, std::enable_if_t<!AreMatchingNonScalarsV< T0, T1 > > > | |
| CProcessNonScalars< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t< AreMatchingNonScalarsV< T0, T1 > > > | |
| CProcessNonScalars< MPL::TypeTuple<>, Factor > | |
| CProcessScalars | |
| CProcessScalars< T, Factor, std::enable_if_t<(Factor::First::value > 1)> > | |
| CScalarRecursion< OperationPair< Sign, F, TreeData0, MPL::TypeTuple< TreeData1... >, Tag > > | |
| ►NRight | |
| CCollectOperands | |
| CCollectOperands< T, PrevOps, std::enable_if_t<!IsPositiveTreeNodeV< T > > > | |
| CFactorOutCandidate | |
| CFactorOutCandidate< T0, MPL::TypeTuple<>, MinusOperands > | |
| CFactorOutHelper | |
| CFactorOutHelper< MPL::TypeTuple< Factorizations... >, MPL::TypeTuple< Done... > > | |
| CFactorSwap | |
| CFactorSwap< A, B, std::enable_if_t<(!HasEinsumFunctorV< A > &&HasEinsumFunctorV< B >)> > | |
| CFactorSwap< A, B, std::enable_if_t<(HasEinsumFunctorV< A >==HasEinsumFunctorV< B > &&LexCompareProductOperationsV< typename A::FunctorType, typename B::FunctorType > > 0)> > | |
| CProcessCandidates< MPL::TypeTuple< T0 >, void > | |
| CProcessCandidates< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t< AreMatchingCandidatesV< Factor, T0 > > > | |
| CProcessCandidates< MPL::TypeTuple< T0, T... >, MPL::TypeWrapper< Factor >, std::enable_if_t<!AreMatchingCandidatesV< Factor, T0 > > > | |
| CProcessCandidates< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t< AreMatchingCandidatesV< T0, T1 > > > | |
| CProcessCandidates< MPL::TypeTuple< T0, T1, T... >, void, std::enable_if_t<!AreMatchingCandidatesV< T0, T1 > > > | |
| CProcessCandidates< MPL::TypeTuple<>, Factor > | |
| CRecursion | |
| CRecursion< OperationPair< Sign, F, MPL::TypeTuple< TreeData0... >, TreeData1, Tag > > | |
| ►NEinsum | |
| CIsMiddleScalarNestedEinsum | |
| CIsMiddleScalarNestedEinsum< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1, std::enable_if_t<(IsEinsumExpression< T1 >::value &&(TensorTraits< T0 >::rank > 0) &&(TensorTraits< T1 >::rank > 0) &&TensorTraits< Operand< 0, T1 > >::rank==0)> > | |
| ►NSums | |
| CExplodeProduct | |
| CIsDistributiveOperation | True for expressions which can be moved inside or outside of sums |
| COperateHelper< Sign, F, Node0, Node1, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&IsUndecomposableScalarV< Node1 > &&!IsOnesNodeV< Node0 > &&!IsOnesNodeV< Node1 >)> > | ! |
| COperateHelper< Sign, F, OperationPair< Sign0, ProdF, MPL::TypeTuple< E00... >, E01, ExplodeTag >, OperationPair< Sign1, ProdF, MPL::TypeTuple< E10... >, E11, ExplodeTag > > | |
| COperateHelper< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Node... >, OnesNode< OnesSign > > | Keep ones as placeholder to the right of tuples of scalar factors |
| COperateHelper< Sign, ScalarEinsumFunctor, Node, OnesNode< OnesSign > > | |
| COperateHelper< Sign, ScalarEinsumFunctor, Node0, Node1, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&!IsOnesNodeV< Node0 > &&!IsUndecomposableScalarV< Node1 > &&!IsScalarFactorizationV< Node1 >)> > | |
| COperateHelper< Sign, ScalarEinsumFunctor, Node0, OperationPair< Sign1, ScalarEinsumFunctor, E10, E11, ExplodeTag >, std::enable_if_t<(IsUndecomposableScalarV< Node0 > &&IsUndecomposableScalarV< E10 >)> > | ! |
| COperateHelper< Sign, ScalarEinsumFunctor, OnesNode< OnesSign >, Node > | |
| COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E0... >, OnesNode<>, ExplodeTag >, TreeNode1, std::enable_if_t<(TensorTraits< TreeExpression< TreeNode1 > >::rank > 0)> > | |
| COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E00... >, E01, ExplodeTag >, OperationPair< Sign1, ScalarEinsumFunctor, E10, E11, ExplodeTag >, std::enable_if_t< IsUndecomposableScalarV< E10 > > > | |
| COperateHelper< Sign, ScalarEinsumFunctor, OperationPair< Sign0, ScalarEinsumFunctor, MPL::TypeTuple< E00... >, E01, ExplodeTag >, TreeNode1, std::enable_if_t< IsUndecomposableScalarV< TreeNode1 > > > | |
| COperateHelper< Sign, ScalarEinsumFunctor, TreeNode0, OperationPair< Sign1, ScalarEinsumFunctor, MPL::TypeTuple< E1... >, OnesNode<>, ExplodeTag >, std::enable_if_t<(TensorTraits< TreeExpression< TreeNode0 > >::rank > 0)> > | |
| COperateHelper< Sign, ScalarEinsumFunctor, TreeNode0, OperationPair< Sign1, ScalarEinsumFunctor, MPL::TypeTuple< E10... >, E11, ExplodeTag >, std::enable_if_t< IsUndecomposableScalarV< TreeNode0 > > > | |
| CProcessExplodeHelper | |
| CProcessExplodeHelper< F, E, TreePos, Tuple0, Tuple1 > | |
| CProcessSumOperands | Hook into the innermost operand tuple of the factor out code |
| CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left >, OnesNode<>, Tag > > | |
| CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left >, Right, Tag > > | |
| CReassembleProductHelper< OperationPair< Sign, ScalarEinsumFunctor, MPL::TypeTuple< Left0, Left1, Left... >, Right, Tag > > | |
| ►NTranspose | |
| CEinsumCommutationHelper | |
| CIsTransposeOfEinsumWithRightEye | |
| ►NProductOperations | |
| CIsLeftAssociative | |
| CIsLeftAssociative< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1 > | TrueType if T can be associated left (i.e |
| CIsRightAssociative< OperationTraits< EinsumOperation< Seq0, Seq1, Dims > >, T0, T1 > | TrueType if F(T0, T1) forms a triple-product that can be associated right from (A*B)*C to A*(B*C) |
| CTreeFactorOutLeftHelper | Default case: TreeData is already associated to the right and not a simple TreeData |
| CTreeFactorOutLeftHelper< OperationPair< Sign, InnerF, TreeData0, TreeData1, OptimizeTag >, std::enable_if_t< IsRightAssociative< InnerF, TreeData0, TreeData1 >::value > > | |
| CTreeFactorOutLeftHelper< TreeData< S, E, Pos > > | Blow-up a simple TreeData by adding a scalar one node at the right |
| CTreeFactorOutRightHelper | Default case: TreeData is already associated to the left and not a simple TreeData |
| CTreeFactorOutRightHelper< OperationPair< Sign, InnerF, TreeData0, TreeData1, OptimizeTag >, std::enable_if_t< IsLeftAssociative< InnerF, TreeData0, TreeData1 >::value > > | |
| CTreeFactorOutRightHelper< TreeData< S, E, Pos > > | Blow-up a simple TreeData by adding a scalar one node at the left |
| CAreBinaryTensorOperands | |
| CAreBinaryTensorOperands< T1, T2, std::enable_if_t<(!(IsClosure< T1 >::value||IsClosure< T2 >::value) &&IsTensorOperand< T1 >::value &&IsTensorOperand< T2 >::value &&(IsTensor< T1 >::value||IsTensor< T2 >::value))> > | |
| CAreBinaryTensorOperands< T1, T2, std::enable_if_t<(IsFieldObject< T1 >::value &&IsFieldObject< T2 >::value &&IsUnaryTensorOperand< T1 >::value &&IsUnaryTensorOperand< T2 >::value)> > | Declare that non-trivial field-objects (non-scalars) qualify as binary tensor arguments, even if both operands are not yet wrapped into their tensor cloths |
| CAreRuntimeComparable | |
| CBlockEye< BlockRank, Seq< Dimensions... >, Field > | "Identity" block tensor formed of BlockRank many copies of BlockSignature multi-indices |
| CConstantTensor< Field, Seq< Dimensions... > > | A tensor where all elements evaluate to the same constant value |
| CDenseMatrixAssigner | |
| CDenseVectorView | |
| CDenseVectorView< T, Storage, 0, 0 > | Specialize for scalars and just cast to the field type |
| CDenseVectorView< T, Storage, 1, 1 > | Start of the affair |
| CDenseVectorView< T, Storage, 1, Rank, std::enable_if_t< Rank !=1 > > | Storage provider, downcast end-point |
| CDenseVectorView< T, Storage, N, N, std::enable_if_t< N >=2 > | Start of the affair |
| CDenseVectorViewElement | |
| CDenseVectorViewElement< T, Storage, 1, Rank > | Recursion endpoint for elements |
| CDerivativeTraits< IndeterminateOperation< Id > > | |
| CDerivativeTraits< ReciprocalOperation > | Derivative expression for component wise invert operation |
| CDerivativeTraits< RestrictionOperation< Positions, Indices > > | Compile-time constant variant |
| CDerivativeTraits< RestrictionOperation< Tensor::Seq< Dims... >, Tensor::Seq<> > > | Runtime-dynamic variant |
| CEinsteinSummation | Contraction of two tensor over a selection set of indices |
| CEvalSExpFAD< OperateFAD< Evaluate, Seq< Id... >, Signature... > > | Functor implementation for evaluateSubExpression() which does forward autodiff |
| CEye< Seq< Dimensions... >, Field > | "Identity" tensor: evaluates to 1 if all indices are the same, to 0 else |
| CHasSpecializedExpressionTraits | Should be specialized to TrueType if for a specific tensor ExpressionTraits need to be re-implemented |
| CIsBlockEye< BlockEye< BlockRank, BlockSignature, Field > > | Identity a non-empty BlockEye |
| CIsComponentWiseOperation< T, std::enable_if_t<(IsReshapeOperation< T >::value||IsTransposeOperation< T >::value||IsRestrictionOperation< T >::value||IsProductOperation< T >::value)> > | Products, restrictions and transpositions do not act componentwise |
| CIsConstKroneckerDelta< KroneckerDelta< Seq< Pos... >, Seq< Pivot... >, Field > > | Evaluate to a true type if the projection is compile-time constant |
| CIsConstRestriction< Restriction< T, Pos, Pivots >, std::enable_if_t< Pos::size()==Pivots::size()> > | Evaluate to a TrueType if the restriction is compile-time constant |
| CIsDynamicRestriction< Restriction< T, Seq< P0, PRest... >, Seq<> > > | Evaluate to a TrueType if the restriction is runtime dynamic |
| CIsKroneckerDelta | Traits in order to identify a Projection class |
| CIsMatchingAutoDiffPlaceholder | Check whehter T is a placeholder which matches the givens indeterminate ids and signature |
| CIsRestriction | Traits in order to identify a Restriction class |
| CIsSelfTransposed< Perm, ConstantTensor< F, Dims >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}))> > | Don't transpose constant tensors if their dimenensions are invariant under the permutation |
| CIsSelfTransposed< Perm, Eye< Dims, F >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}))> > | Don't transpose eye tensors if their dimensions are invariant under the permutation |
| CIsSelfTransposed< Perm, KroneckerDelta< Dims, Index, Field >, std::enable_if_t<(!isSimple(Perm{}) &&isInvariant(Dims{}, Perm{}) &&isInvariant(Index{}, Perm{}))> > | Don't transpose constant tensors |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsBinaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&HasSelfTransposedOperand< Perm, 0, T >::value &&HasSelfTransposedOperand< Perm, 1, T >::value)> > | Sums- and differences of self-transposed tensors remain self-transposed |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsEinsumExpression< T >::value &&IsRuntimeEqualExpression< Operand< 0, T > >::value &&IsRuntimeEqualExpression< Operand< 1, T > >::value &&std::is_same< std::decay_t< Operand< 0, T > >, std::decay_t< Operand< 1, T > > >::value &&std::is_same< typename T::LeftIndexPositions, typename T::RightIndexPositions >::value &&std::is_same< Perm, SequenceCat< typename T::RightArgs, typename T::LeftArgs > >::value)> > | Einsum operations over the same set of indices of identical tensors are self-transposed when exchanging the complete index set |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsProductExpression< T >::value &&((TensorTraits< Expressions::Operand< 0, T > >::rank==0 &&HasSelfTransposedOperand< Perm, 1, T >::value)||(TensorTraits< Expressions::Operand< 1, T > >::rank==0 &&HasSelfTransposedOperand< Perm, 0, T >::value)))> > | Products of scalars with self-transposed tensors remain self-transposed |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsProductExpression< T >::value &&(TensorTraits< Expressions::Operand< 0, T > >::rank > 0 &&TensorTraits< Expressions::Operand< 1, T > >::rank > 0) &&HasSelfTransposedOperand< TranspositionForOperand< 0, Perm, T >, 0, T >::value &&HasSelfTransposedOperand< TranspositionForOperand< 1, Perm, T >, 1, T >::value)> > | Products (ProductTensor, EinsteinSummation) are selftransposed if the permutation respects the product structure and the arguments are self-transposed with respect to the induced permutation |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&!isSimple(Perm{}) &&IsUnaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&HasSelfTransposedOperand< Perm, 0, T >::value)> > | Unary operations acting componentwise do not alter the self-transposedness |
| CIsSelfTransposed< Perm, T, std::enable_if_t<(IsDecay< Perm >::value &&IsDecay< T >::value &&IsTensorOperand< T >::value &&isSimple(Perm{}))> > | Ignore do-nothing permutations |
| CIsSelfTransposed< Seq< Perm... >, BlockEye< Rank, Dims, Field >, std::enable_if_t<(!isSimple(Seq< Perm... >{}) &&std::is_same< SequenceProd< Rank, MakeIndexSequence< Dims::size()> >, Seq< Get< Perm, SequenceProd< Rank, MakeIndexSequence< Dims::size()> > >::value... > >::value)> > | Don't transpose constant tensors if their dimenensions are invariant under the permutation |
| CIsSubordinateTransposition | |
| CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank &&IsEinsumExpression< T >::value)> > | Inspect einsum expressions |
| CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank &&IsTensorProductExpression< T >::value)> > | Inspect product expressions |
| CIsSubordinateTransposition< Perm, T, std::enable_if_t<(IsDecay< T >::value &&IsUnaryExpression< T >::value &&IsComponentWiseExpression< T >::value &&isPermutation(Perm{}) &&Perm::size()==TensorTraits< T >::rank)> > | Component-wise unary operations are ok if the permutation operates on the signature |
| CIsTensor< T, std::enable_if_t<(IsDecay< T >::value &&T::Signature::size()==T::rank)> > | A tensor is something with a signature and a rank :) |
| CIsTensorOperand | |
| CIsTensorOperand< T, std::enable_if_t<!IsDecay< T >::value > > | |
| CIsTensorOperand< T, std::enable_if_t<(IsTensor< T >::value &&IsDecay< T >::value)> > | |
| CIsTensorOperand< TypedValue::FractionConstant< Int, N, D > > | Inject FractionConstant as valid tensor operand |
| CIsTensorOperand< TypedValue::NamedConstant< T, Name... > > | Inject NamedConstant as valid tensor operand |
| CIsTransposition | Traits in order to identify a TensorView class |
| CIsUnaryTensorOperand | We should not inject scalars into unary expressions as this very easily will lead to ambiguities |
| CKroneckerDelta< Seq< D0, RestDims... >, Seq<>, Field > | "Kronecker" tensor: evaluates to 1 for exactly one tuple of indices |
| CKroneckerDelta< Seq< Dimensions... >, Seq< PivotIndices... >, Field > | "Kronecker" tensor: evaluates to 1 for exactly one tuple of indices |
| CLinearStorageTensor | A tensor wrapping an object with an operator[] |
| CLinearStorageTensor< Container, Seq< Dimensions... > > | A tensor wrapping an object with an operator[] and a value_type |
| COperandRank | Generate the rank of the N-th operand if applicable |
| COperandRank< N, T, std::enable_if_t<(N >=Arity< T >::value)> > | Generate ~0UL if T has not so many operands |
| COperateFAD< Evaluate, Seq< Id... >, Signature... > | Implement forward AD by transforming an expression to its evaluated AD expression |
| CProductTensor | Compute the component-wise product ".[i][j]" over selected indices: |
| CReshape< Parent, Seq< Dimensions... > > | Wraps a tensor using the same data but with a different signature |
| CRestriction | A meta-tensor restricting a given tensor w.r.t |
| CRestriction< Tensor, Seq< IndexPositions... >, Seq< PivotIndices... > > | Restriction to index sub-space with compile-time constant pivot indices |
| CRestriction< Tensor, Seq< IndexPositions... >, Seq<> > | Restriction to index sub-space with run-time dynamic pivot indices |
| CTensorBase | Base class for all tensors |
| CTensorResult | The wrapper class wrapped around each expression result |
| CTensorTraits< TypedValue::FractionConstant< Int, N, D > > | Inject FractionConstant as valid tensor operand |
| CTensorTraits< TypedValue::NamedConstant< T, Name... > > | Inject NamedConstant as valid tensor operand |
| CTerminalDependsOn | |
| CTerminalDependsOn< T, IndexConstant< Id >, Signature, std::enable_if_t<(!IndeterminateMatch< T, IndexConstant< Id > >::value &&!IsPlaceholderExpression< T >::value)> > | |
| CTransposition< Tensor, Seq< Perm... > > | A class applying a transposition to the given tensor's indices |
| CTranspositionForOperandHelper | Construct the induced transposition for operand N if Perm is subordinate to the expression structure of T |
| CTranspositionForOperandHelper< N, Perm, T, std::enable_if_t<(IsSubordinateTransposition< Perm, T >::value &&IsTensorProductExpression< T >::value &&(N< Arity< T >::value))> > | |
| CTranspositionForOperandHelper< N, PermArg, T, std::enable_if_t<(IsSubordinateTransposition< PermArg, T >::value &&IsEinsumExpression< T >::value &&(N< Arity< T >::value))> > | |
| ►NTypedValue | |
| CFractionConstant | A class implementing compile-time constant fractions of integers |
| CIsFractionConstant | |
| CIsSign | |
| CIsSign< T, std::enable_if_t< IsFractionConstant< T >::value > > | TrueType is T models a sign which means it is a FractionConstant<I, N, D>, D == 1 and N*N <= 1 |
| CIsSign< T, std::enable_if_t<!IsFractionConstant< T >::value > > | Only fraction constants can be signs |
| CNamedConstant | A named constant wraps a constant of the given type T tagging it with the given character sequence |
| CNamedConstant< T, '1', '_', 'P', 'I'> | 1/pi form glibc implementation |
| CNamedConstant< T, '2', '_', 'P', 'I'> | 2/pi form glibc implementation |
| CNamedConstant< T, '2', '_', 'S', 'Q', 'R', 'T', 'P', 'I'> | 2/sqrt(pi) form glibc implementation |
| CNamedConstant< T, 'E'> | E form glibc implementation |
| CNamedConstant< T, 'L', 'N', '1', '0'> | Log_e 10 form glibc implementation |
| CNamedConstant< T, 'L', 'N', '2'> | Log_e 2 form glibc implementation |
| CNamedConstant< T, 'L', 'O', 'G', '1', '0', 'E'> | Log_10 e form glibc implementation |
| CNamedConstant< T, 'L', 'O', 'G', '2', 'E'> | Log_2 e form glibc implementation |
| CNamedConstant< T, 'P', 'I', '_', '2'> | Pi/2 form glibc implementation |
| CNamedConstant< T, 'P', 'I', '_', '4'> | Pi/4 form glibc implementation |
| CNamedConstant< T, 'P', 'I'> | Pi form glibc implementation |
| CNamedConstant< T, 'S', 'Q', 'R', 'T', '1', '_', '2'> | 1/sqrt(2) form glibc implementation |
| CNamedConstant< T, 'S', 'Q', 'R', 'T', '2'> | Sqrt(2) form glibc implementation |
| CAbsOperation | Abs |
| CAcceptAllFunctor | Functor for TransformSequence: unconditionally accept |
| CAcceptEqualFunctor | Functor for TransformSequence: accept if result is either equal or different from original value |
| CAcceptInputInRangeFunctor | Accept if input-value is in range of given bounds |
| CAcceptInputValueFunctor | Accept if input-value is either equal or unequal to given value |
| CAcceptModuloFunctor | Accept if input-value MOD P = R |
| CAcoshOperation | Inverse hyperbolic cosine |
| CAcosOperation | Taking the arc cosine of an object |
| CAdaptiveFemScheme | Abstract space adaptative FEM scheme |
| CAddBitFunctor | Add given bit to all masks |
| CAddBitShiftLeftFunctor | Add a set bit at left-shifted position |
| CAddBitShiftRightFunctor | Add a set bit at right-shifted position |
| CAndPredicate | Logical "and" for two perdicates |
| CAsinhOperation | Inverse hyperbolic sine |
| CAsinOperation | Taking the arc sine of an object |
| CAssumeOperation | Assume operations attach a property to the wrapped expression |
| CAtan2Operation | Taking the arctan of an object |
| CAtanhOperation | Inverse hyperbolic tangens |
| CAtanOperation | Taking the arctan of an object |
| CBasicFemScheme | Abstract non-adaptive basic FEM scheme |
| CBulkBlockConstraints | A default implementation for bulk block constraints |
| CCanPromoteTupleTypes | |
| CCanPromoteTupleTypes< T, std::enable_if_t< sizeof(TupleScalarPromotionType< T >) >=0 > | TrueType if the type of the tuple T can be promoted to another type |
| CCase | Case-structure for multi-conditional switch |
| CCeilOperation | Ceil |
| CConstantExpression | A constant |
| CContainerTuple | Create a tuple of values from a tuple of containers |
| Ccopy_cv_reference | Export a type copy_cv_reference::type which has the same qualifiers as T and decays to the decay of U |
| CCoshOperation | Hyperbolic cosine |
| CCosOperation | Taking the cosine of an object |
| CDataOutputParameters | Potentially overwrite some parameters |
| CDefaultQuadratureTraits | Helper traits-class, defining likely quadrature types |
| CDirichletConstraints< DiscreteFunctionSpace, BoundaryValues, Indicator, std::enable_if_t<(HasEmptySupport< BoundaryValues >::value||IndicatorTraits< Indicator >::emptySupport)> > | Spezialization of Dirichlet constraints for emptyboundaryindicator |
| CDirichletConstraints< DiscreteFunctionSpace, BoundaryValues, Indicator, std::enable_if_t<(IsWrappableByConstLocalFunction< BoundaryValues >::value &&IsBoundaryIndicator< Indicator >::value &&!IndicatorTraits< Indicator >::emptySupport)> > | Implementation of Dirichlet constraints given a boundary}; supported function |
| CDirichletConstraints< DiscreteFunctionSpace, Model, void, std::enable_if_t< true &&IsPDEModel< Model >::value &&!HasEmptySupport< Model >::value > > | Implementation of Dirichlet constraints given a PDE-model |
| CDofMapperTupleDataHandle | Potential all - all communication for mapped data |
| CDofMapperTupleDataHandleTraits | Traits for just something indexable |
| CEinsumOperation | Einstein summation, i.e |
| CEllipticEstimator | An standard residual estimator for elliptic problems |
| CEllipticFemScheme | Adaptive fem-scheme for "elliptic" problems |
| CEllipticOperator | A class defining an elliptic operator |
| CEmptyBlockConstraints | A class modelling do-nothing constraints |
| CEqOperation | == |
| CErfOperation | Erf |
| CExpOperation | Exponentiation of an object |
| CExpressionTraits | Default expression traits definition is a recursion in order to ease disambiguation |
| CExpressionTraits< Constant< I, V > > | Explicit expression traits for integer constants |
| CExpressionTraits< FractionConstant< Int, N, D > > | Override ExpressionTraits for FractionConstant |
| CExpressionTraits< Model, std::enable_if_t< IsPDEModel< Model >::value >, TraitsPriority::Secondary > | Override default expression traits s.t |
| CExpressionTraits< T, std::enable_if_t< Expressions::IsClosure< T >::value >, BaseTraitsLevel > | Use traits of enclosed type for closure expressions |
| CExpressionTraits< T, std::enable_if_t<!IsDecay< T >::value >, DecayTraitsLevel > | Forward to the traits class for the decay type |
| CExpressionTraits< T, std::enable_if_t<!IsExpression< T >::value||IsSelfExpression< T >::value >, BaseTraitsLevel > | Default expression traits for terminal expressions or non-expressions just look at the tag-classes |
| CExpressionTraits< T, std::enable_if_t<(IsExpression< T >::value &&!IsSelfExpression< T >::value &&!Expressions::IsClosure< T >::value)>, BaseTraitsLevel > | Default Expression-traits for any non-terminal expression use the induced traits of the operation while allowing overrides from attached tag-base-classes |
| CExpressionTraits< T, void, DefaultTraitsLevel > | A traits class in order to collect properties of expressions |
| CExpressionTraits< Tensor::AutoDiffPlaceholder< Id, Signature, T, DT > > | |
| CExpressionTraits< TypedValue::NamedConstant< T, Name... > > | Override ExpressionTraits for NamedConstant |
| CExtractFunctor | A functor which extracts values from a global array and copies them to a local array |
| CExtractFunctor< T *, GlobalArray > | A functor which extracts values from a global array and copies them to a local array |
| CFieldPromotion | Promote potentially different numeric field types to a "closure" type |
| CFieldTraits | Helper class for specializing Dune::FieldTraits |
| CFloorOperation | Floor |
| CGeometryInformation | Export some hard-to-get-at things for geometries |
| CGeOperation | >= |
| CGet | Gets the type of the n-th element of a tuple-like or the std::integral_constant corresponding to the n-th element of a sequence |
| CGtOperation |
|
| CHasPropertyFunctor | |
| CHasResize | |
| CHasUnaryMinus | |
| CHasUnaryMinus< T, std::enable_if_t<(sizeof(decltype(-std::declval< T >())) >=0)> > | TrueType if a T allows for the unary minus operator |
| CIdentityFunctor | Identity functor |
| CIdentityOperation | Identity, i.e. just wrap the object |
| CIndependentExpression | An independent expression is an expression which does not depend on external state |
| CIndeterminateOperation | Indeterminate operation, wrap another object and attach an id |
| CIndexFunctor | Index functor |
| CIntersectionDataHandle | General intersection - intersection communication which communicates for each intersection a potentially variable number of data-items |
| CInverseMapSequenceFunctor | Map a value to the index of the value in Values |
| CIsAlwaysFalse | Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to AlwaysFalse |
| CIsAlwaysFalse< Predicate, std::enable_if_t<!Predicate<>::value > > | Assume a predicate is a traits-class and would never evaluate to false unless it is equivalent to AlwaysFalse |
| CIsAlwaysTrue | Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to AlwaysTrue |
| CIsAlwaysTrue< Predicate, std::enable_if_t< Predicate<>::value > > | Assume a predicate is a traits-class and would never evaluate to true unless it is equivalent to AlwaysTrue |
| CIsApplicableTo | Is TrueType if an F can be invoked with an E |
| CIsArray | |
| CIsArray< std::array< T, N > > | TrueType if T is a std::array |
| CIsArray< T, std::enable_if_t<!IsDecay< T >::value > > | Forward to decay if T is not a decay type |
| CIsBoolConstant | |
| CIsBoolConstant< BoolConstant< V > > | TrueType for bool constant |
| CIsBoolConstant< T & > | Forward to decay traits class for non decay types |
| CIsBoolConstant< T && > | Forward to decay traits class for non decay types |
| CIsDefined | |
| CIsDefined< T, std::enable_if_t<(std::is_object< T >::value &&!std::is_pointer< T >::value &&(sizeof(T) >=0))> > | TrueType if T is an object which is not a pointer |
| CIsDistributiveOperation | True for expressions which can be moved inside or outside of sums |
| CIsDynamicOperation | Should be overloaded to std::true_type for operations which introduce runtime variable data into the expression as part of the operation |
| CIsEvenFunctor | Transform to bool sequence of even indices |
| CIsIndexSequence | |
| CIsIndexSequence< IndexSequence< Ints... > > | TrueType for integer sequences with value_type std::size_t |
| CIsIntegral | TrueType if I is an integral type |
| CIsIntegral< TypedValue::FractionConstant< I, N, 1 > > | Some FractionConstants are integral |
| CIsIntegralConstant | FalseType by default |
| CIsIntegralConstant< Constant< T, V > > | TrueType for integral_constant |
| CIsOddFunctor | Transform to bool sequence of even indices |
| CIsProductOperation | Evaluate to std::true_type if the operation is product-like |
| CIsQuadraturePoint | |
| CIsQuadraturePoint< Fem::QuadraturePointWrapper< Quadrature > > | Identify quadrature points |
| CIsQuadraturePoint< T, std::enable_if_t<!IsDecay< T >{}> > | |
| CIsScalar | Std::true_type if F is an "elementary" scalar |
| CIsScalar< F, std::enable_if_t<(std::is_convertible< F *, typename FieldTraits< F >::field_type * >::value &&(std::numeric_limits< typename FieldTraits< F >::real_type >::is_iec559||std::numeric_limits< typename FieldTraits< F >::real_type >::is_integer))> > | Standard floating point types and integral types are scalars, also FieldVectors of dimension 1 convertible to standard floating point types |
| CIsScalar< TypedValue::FractionConstant< I, N, D > > | FractionConstants are scalars |
| CIsScalar< TypedValue::NamedConstant< T, Name... > > | NamedConstants are scalars if the wrapped type is |
| CIsSequence | |
| CIsSequence< Sequence< T, Ints... > > | Evaluate to TrueType of integer sequences |
| CIsTupleLike | |
| CIsTupleLike< T, std::enable_if_t<(std::tuple_size< std::decay_t< T > >::value >=0)> > | Evaluate to true if T behaves more or less like a tuple |
| CIsVolatileOperation< IndeterminateOperation< Id > > | Indeterminates are also volatile by design |
| CIsVolatileOperation< PlaceholderOperation< Placeholder > > | Placeholder expressions are volatile by design, unless overridden by a RuntimEqualExpression tag |
| CLeOperation | <= |
| CLGammaOperation | ;gamma |
| CLocalObjectFactory | Define a factory for a "local object" which has a constructor which accepts a single argument, a "global object" |
| CLocalObjectStack | Local object stack which (hopefully) efficiently caches local objects |
| CLogicalAndOperation | Logical And |
| CLogicalNotOperation | Logical Not |
| CLogicalOrOperation | Logical Or |
| CLogOperation | Taking the logarithm of an object |
| CLtOperation | < |
| CMakeType | |
| CMapSequenceFunctor | Map sequence values to values specified by other sequence, e.g |
| CMapSequenceFunctor< Sequence< I > > | Per convention just use the identiy for the empty value sequence |
| CMaxOperation | Max |
| CMaybeLumpingQuadratureTraits | Helper traits-class, defining likely quadrature types for mass-lumping |
| CMinOperation | Min |
| CMinusEqOperation | A -= B |
| CMinusOneExpression | A tag structure which can be attached as base-class to expressions modelling a 1 (in a field, e.g., or the constant-one function) |
| CMinusOperation | Subtraction of two objects and unary minus |
| CModelBase | A structure defining some basic default types and methods |
| CMultiplyOffsetFunctor | Multiply-offset functor |
| CMutableExpression | Something which may be change between different evaluations of an expression |
| CMutableLocalObjectStorageProvider | Provide a writable object stack for technical reasons |
| CMutableNoStorageProvider | Provide a writable pseudo object stack which is only a reference to the global object |
| CNegativeExpression | An expression which is known to be negative |
| CNeOperation | != |
| CNonZeroExpression | Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused |
| COneExpression | A tag structure which can be attached as base-class to expressions modelling a 1 (in a field, e.g., or the constant-one function) |
| COperationTraits< EinsumOperation< Pos1, Pos2, Dims > > | Einstein summation, i.e |
| COperationTraits< ReshapeOperation< Sig > > | Reshape a tensor to another signature |
| COperationTraits< TensorProductOperation< Pos1, Pos2, Dims > > | Component-wise product over given index-set |
| COperationTraits< TransposeOperation< Perm > > | Permutation of index positions of tensors |
| COperatorTypeSelector | |
| COrPredicate | Logical "or" for two perdicates |
| CPairFunctor | Generate a compound functor out of two functors |
| CParabolicEulerEstimator | Residual estimator for the heat equation |
| CParabolicFemScheme | Basic parabolic fem-scheme class |
| CPieceWiseConstantExpression | Something constant on a given entity |
| CPlaceholderOperation | Placeholder operation wraps another object and attaches an id to it |
| CPlusEqOperation | A += B |
| CPlusOperation | Addition of two objects |
| CPointWrapperQuadrature | A wrapper class which allows to "simulate" a Dune::Fem::QuadraturePointWrapper |
| CPositiveExpression | An expression which is known to be positive |
| CPowOperation | Taking something to the power of something |
| ►CPredicateProxy | Wrap the given predicate class F into another one with spcial requirements |
| CForwardFirst | Discard any but the first template parameter, instantiate F with T and Rest |
| CUnary | Generate a one-parameter template to support template-template arguments with a single argument |
| CPredicateWrapper | Wrap a predicate into a class which can be passed on as argument |
| CReciprocalOperation | Inversion of a scalar object |
| CRegularZeroExpression | Non-singular, but somehow zero, whatever that means |
| Cremove_const | Export a type trough remove_const::type as follows: |
| CReshapeOperation | Signature of index positions of tensors |
| CRestrictionOperation | AutoDiff operation |
| CRoundOperation | Round |
| CRuntimeEqualExpression | A tag structure signalling that objects of this type can be considered to yield the same values at runtime, if encountered in the same expression |
| CSameDecay | TrueType if T1 and T2 have the same decay types, otherwise FalseType |
| CScopedRedirect | A class to redirect streams |
| CSemiNegativeExpression | Less equal 0 expression |
| CSemiPositiveExpression | Greater equal 0 expression |
| CSinhOperation | Hyperbolic sine |
| CSinOperation | Taking the sine of an object |
| CSMultiplyEqOperation | A *= s |
| CSMultiplyOperation | Multiplication by scalars from the left |
| CSolverSelector | Select one appropriate (linear) solver depending on whether the model is symmetric and/or semidefinite |
| CSqrtOperation | Taking the square root of an object |
| CSquareOperation | Taking the square of an object |
| CSubExpressionOperation | Kind of placeholder |
| CSwitch | Recursion for a multi-conditional switch |
| CSwitch< Case< C, T > > | Recursion end-point: if the last template parameter to SwitchType is a case then export T as SwitchCase<C,T>::Type if C is true |
| CSwitch< T > | Recursion endpoint: If the terminating template parameter to SwitchType is not a Case template, then export T as Switch<T>::Type |
| CTanhOperation | Hyperbolic tangens |
| CTanOperation | Taking the tangens of an object |
| CTensorProductOperation | Component-wise product over given index-set |
| CTerminalExpression | A terminal expression is an "expression end-point", i.e |
| CTernaryOperation | IfOperation |
| CTGammaOperation | Tgamma |
| CTimeProviderTraits | Type of time and time-step values |
| CTimeView | Generate a view on the current time-step |
| CTransformAtIndexFunctor | Applies another functor only to the elements at the specified positions given by the Index parameter pack |
| CTransposeOperation | Permutation of index positions of tensors |
| CTrueErrorEstimator | "estimator" which return the "true" error with respect to some given function in some standard norm |
| CTupleFunctor | Generate a compound functor out of a tuple of functors |
| CTypedValueExpression | A tag structure signalling that this expression carries its value in its type |
| CTypeString | A class constructing the name of another type |
| CUnaryFilterFunctor | Filter-proxy for TransformSequence template alias |
| CUnaryKeepAtFunctor | Alternative: avoid bit-masks and use ContainsValue<> template |
| CUnaryNotFunctor | Negate a given unary functor |
| CUniqueExpression | A tag for use with assume() to generate a unique type which is assumed to be "runtime equal" by inheriting from RuntimeEqualExpression |
| CVolatileExpression | A volatile expression will not be replaced by its value except for RuntimeEqual optimizations |
| CZeroExpression | A tag structure which can be attached as base class to zero-expressions like the ZeroGridFunction, the ZeroModel, the ZeroFunctional |
| CZeroExpressionTraits | ExpressionTraits for any zero-expression |
| CFieldTraits< ACFem::GridFunction::ElementMeasurePlaceholder< GridPart > > | Specialize Dune::FieldTraits |
| CFieldTraits< ACFem::GridFunction::LocalFunctionHessianPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
| CFieldTraits< ACFem::GridFunction::LocalFunctionJacobianPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
| CFieldTraits< ACFem::GridFunction::LocalFunctionPlaceholder< LocalFunction, IndeterminateId > > | Specialize Dune::FieldTraits |
| ▼Nstd | STL namespace |
| Cis_convertible< Dune::ACFem::Tensor::TensorResult< T >, Dune::FieldVector< Field, 1 > > | |
| Cis_same< Dune::FieldVector< Field, 1 >, Dune::DenseVector< T > > | |
|
Legal Statements / Impressum |
Hosted by TU Dresden & Uni Heidelberg |
generated with Hugo v0.111.3
(Mar 12, 23:28, 2025)