ExpressionTraits

"Tag"-structures for each supported algebraic operation, used to distinguish the various expression template classes from each other. More...

Classes
struct	Dune::ACFem::IsScalar< TypedValue::FractionConstant< I, N, D > >
	FractionConstants are scalars. More...
struct	Dune::ACFem::IsScalar< TypedValue::NamedConstant< T, Name... > >
	NamedConstants are scalars if the wrapped type is. More...
struct	Dune::ACFem::IsIntegral< TypedValue::FractionConstant< I, N, 1 > >
	Some FractionConstants are integral. More...
struct	Dune::ACFem::ExpressionTraits< FractionConstant< Int, N, D > >
	Override ExpressionTraits for FractionConstant. More...
struct	Dune::ACFem::ExpressionTraits< TypedValue::NamedConstant< T, Name... > >
	Override ExpressionTraits for NamedConstant. More...
struct	Dune::ACFem::ExpressionTraits< T, SFINAE, Priority >
	Default expression traits definition is a recursion in order to ease disambiguation. More...
struct	Dune::ACFem::ExpressionTraits< T, void, DefaultTraitsLevel >
	A traits class in order to collect properties of expressions. More...
struct	Dune::ACFem::ExpressionTraits< T, std::enable_if_t<!IsDecay< T >::value >, DecayTraitsLevel >
	Forward to the traits class for the decay type. More...
struct	Dune::ACFem::ZeroExpressionTraits< T >
	ExpressionTraits for any zero-expression. More...
struct	Dune::ACFem::Expressions::AreRuntimeEqual< 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. More...
struct	Dune::ACFem::Expressions::AreRuntimeEqual< T1, T2, SFINAE >
	FalseType by default. More...
struct	Dune::ACFem::Expressions::AreRuntimeEqual< 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. More...
struct	Dune::ACFem::Expressions::IsBasicRuntimeEqual< T, std::enable_if_t< IsSubExpressionExpression< T >::value > >
	SubExpressionOperation expressions qualify for IsRuntimeEqual if the contained sub-expression qualifies. More...
struct	Dune::ACFem::Expressions::AreRuntimeEqual< T1, T2, std::enable_if_t<(IsSubExpressionExpression< T1 >::value &&IsSubExpressionExpression< T2 >::value)> >
	FalseType by default. More...
struct	Dune::ACFem::TerminalExpression
	A terminal expression is an "expression end-point", i.e. More...
struct	Dune::ACFem::VolatileExpression
	A volatile expression will not be replaced by its value except for RuntimeEqual optimizations. More...
struct	Dune::ACFem::RuntimeEqualExpression
	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. More...
struct	Dune::ACFem::UniqueExpression< id >
	A tag for use with assume() to generate a unique type which is assumed to be "runtime equal" by inheriting from RuntimeEqualExpression. More...
struct	Dune::ACFem::IndependentExpression
	An independent expression is an expression which does not depend on external state. More...
struct	Dune::ACFem::PieceWiseConstantExpression
	Something constant on a given entity. More...
struct	Dune::ACFem::ConstantExpression
	A constant. More...
struct	Dune::ACFem::TypedValueExpression
	A tag structure signalling that this expression carries its value in its type. More...
struct	Dune::ACFem::MutableExpression
	Something which may be change between different evaluations of an expression. More...
struct	Dune::ACFem::SemiPositiveExpression
	Greater equal 0 expression. More...
struct	Dune::ACFem::SemiNegativeExpression
	Less equal 0 expression. More...
struct	Dune::ACFem::NonZeroExpression
	Complementary to ZeroExpression for use in std::conditional, for example, otherwise unused. More...
struct	Dune::ACFem::RegularZeroExpression
	Non-singular, but somehow zero, whatever that means. More...
struct	Dune::ACFem::ZeroExpression
	A tag structure which can be attached as base class to zero-expressions like the ZeroGridFunction, the ZeroModel, the ZeroFunctional. More...
struct	Dune::ACFem::PositiveExpression
	An expression which is known to be positive. More...
struct	Dune::ACFem::NegativeExpression
	An expression which is known to be negative. More...
struct	Dune::ACFem::OneExpression
	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) More...
struct	Dune::ACFem::MinusOneExpression
	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) More...

Typedefs
template<class T , bool Exclusive = true>
using	Dune::ACFem::IsFractionOperand = BoolConstant<(IsScalar< T >::value &&!(Exclusive &&IsFractionConstant< T >::value) &&!IsIntegralConstant< T >::value &&!IsExpression< T >::value)>
	Allow scalars to mate with FractionConstants, but do not interfere with std::integral_constant and expression types.
template<class T >
using	Dune::ACFem::IsTypedValue = BoolConstant< ExpressionTraits< T >::isTypedValue >
	Compile-time true if T is a "typed value", e.g. a std::integral_constant.
template<class T >
using	Dune::ACFem::IsTypedValueReference = BoolConstant< std::is_reference< T >::value &&IsTypedValue< T >::value >
	Compile-time true if T is a reference to a "typed value".

Functions
template<class T , std::enable_if_t< IsFractionOperand< T, false >::value, int > = 0>
constexpr auto	Dune::ACFem::zero (T &&t)
	Use the zero fraction as canonical zero element for scalars.
template<class T , std::enable_if_t< IsFractionOperand< T, false >::value, int > = 0>
constexpr auto	Dune::ACFem::one (T &&t)
	Use the one fraction as canonical zero element for scalars.
template<class T , std::enable_if_t< IsSubExpressionExpression< T >::value, int > = 0>
constexpr decltype(auto)	Dune::ACFem::Expressions::subExpressionExpression (T &&t)
	Recurse to the wrapped expression if T fulfills IsSubExpressionExpression<T>. More...

TagUtilities
@
template<class A , class Tag >
using	Dune::ACFem::HasTag = std::is_base_of< Tag, std::decay_t< A > >
	Evaluate to std::true_type if std::decay_t<A> is derived from Tag, otherwise to std::false_type.

SignComparisons
Some constexpr operators to support symbolic notations.
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator<= (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator>= (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator< (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator> (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator== (const Expression &, Constant< Int, I >)
template<class Expression , class Int , Int I>
constexpr std::enable_if_t< OwnsExpressionTraits< Expression >::value, bool >	Dune::ACFem::operator!= (const Expression &, Constant< Int, I >)
template<class T >
constexpr auto	Dune::ACFem::expressionTraits ()
template<class T >
constexpr auto	Dune::ACFem::expressionTraits (T &&)

Detailed Description

"Tag"-structures for each supported algebraic operation, used to distinguish the various expression template classes from each other.

Function Documentation

subExpressionExpression()

template<class T , std::enable_if_t< IsSubExpressionExpression< T >::value, int > = 0>

constexpr decltype(auto) Dune::ACFem::Expressions::subExpressionExpression ( T &&  t )

constexpr

Recurse to the wrapped expression if T fulfills IsSubExpressionExpression<T>.

Don't recurse to the wrapped expression if T does not fulfill IsSubExpressionExpression<T>.