BoundaryFunctionExpressions

Similar to the WrapperExpressionOptimiztation, but rather not an optimization. More...

Functions
template<class Function , class Indicator >
static auto	Dune::ACFem::operator- (const BoundarySupportedFunction< Function, Indicator > &f_) -> BoundarySupportedFunction< decltype(-f_.function()), Indicator >
	-Wrapped(f) = Wrapped(-f)
template<class Function , class Indicator >
static auto	Dune::ACFem::operator+ (const BoundarySupportedFunction< Function, Indicator > &f_) -> BoundarySupportedFunction< Function, Indicator >
	+Wrapped(f) = Wrapped(f)
template<class Left , class Right , class LeftInd >
static auto	Dune::ACFem::operator+ (const BoundarySupportedFunction< Left, LeftInd > &f_, const Fem::Function< typename Right::FunctionSpaceType, Right > &g_) -> decltype(asBndryFct(asExprArg(f_)+g_))
	Wrapped(f) + g = Wrapped(f + g)
template<class Left , class Right , class RightInd >
static auto	Dune::ACFem::operator+ (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_+asExprArg(g_)))
	f + Wrapped(g) = Wrapped(f + g)
template<class ZeroExpression , class Left , class LeftInd >
static auto	Dune::ACFem::operator+ (const BoundarySupportedFunction< Left, LeftInd > &f_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &g_) -> decltype(asBndryFct(asExprArg(f_)+g_))
	Wrapped(f) + zero = Wrapped(f + zero) More...
template<class ZeroExpression , class Right , class RightInd >
static auto	Dune::ACFem::operator+ (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_+asExprArg(g_)))
	zero + Wrapped(g) = Wrapped(zero + g) More...
template<class F , class FC , class Z >
static auto	Dune::ACFem::operator+ (const BoundarySupportedFunction< F, FC > &f_, const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< F, FC >
	Wrapped(f) + Empty = Wrapped(f)
template<class F , class FC , class Z >
static auto	Dune::ACFem::operator+ (const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FC > &f_) -> BoundarySupportedFunction< F, FC >
	Empty + Wrapped(f) = Wrapped(f)
template<class Z1 , class Z2 >
static BoundarySupportedFunction< ZeroGridFunction< typename Z1::FunctionSpaceType, typename Z1::GridPartType >, EmptyBoundaryIndicatorType >	Dune::ACFem::operator+ (const BoundarySupportedFunction< Z1, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Z2, EmptyBoundaryIndicatorType > &z2_)
	Empty + Empty = Empty.
template<class Left , class Right , class LeftInd , class RightInd >
static auto	Dune::ACFem::operator- (const BoundarySupportedFunction< Left, LeftInd > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asExprArg(f_) - asExprArg(g_)))
	Wrapped(f) - Wrapped(g) = Wrapped(f - g)
template<class Left , class Right , class LeftInd >
static auto	Dune::ACFem::operator- (const BoundarySupportedFunction< Left, LeftInd > &f_, const Fem::Function< typename Right::FunctionSpaceType, Right > &g_) -> decltype(asBndryFct(asExprArg(f_) - g_))
	Wrapped(f) - g = Wrapped(f - g)
template<class Left , class Right , class RightInd >
static auto	Dune::ACFem::operator- (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(f_ - asExprArg(g_)))
	f - Wrapped(g) = Wrapped(f - g)
template<class F , class FC , class Z >
static auto	Dune::ACFem::operator- (const BoundarySupportedFunction< F, FC > &f_, const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< F, FC >
	Wrapped(f) - Empty = Wrapped(f)
template<class F , class FC , class Z >
static auto	Dune::ACFem::operator- (const BoundarySupportedFunction< Z, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FC > &f_) -> decltype(-f_)
	Empty - Wrapped(f) = Wrapped(-f)
template<class Z1 , class Z2 >
static BoundarySupportedFunction< ZeroGridFunction< typename Z1::FunctionSpaceType, typename Z1::GridPartType >, EmptyBoundaryIndicatorType >	Dune::ACFem::operator- (const BoundarySupportedFunction< Z1, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Z2, EmptyBoundaryIndicatorType > &z2_)
	Empty - Empty = Empty.
template<class Function , class Indicator >
static auto	Dune::ACFem::operator* (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(s_ *asExprArg(f_))))
	s * Wrapped(f) = Wrapped(s * f)
template<class Function >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridPartType >, EmptyBoundaryIndicatorType >	Dune::ACFem::operator* (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, EmptyBoundaryIndicatorType > &f_)
	s * Wrapped(f, Empty) = Wrapped(zero, Empty)
template<class Function , class Indicator >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Function, Indicator > &f_, const typename Function::RangeFieldType &s_) -> decltype(s_ *f_)
	Wrapped(f) * s = Wrapped(s * f)
template<class Parameter , class Function , class Indicator >
static auto	Dune::ACFem::operator* (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(asImp(p_) *asExprArg(f_))))
	Param * Wrapped(f) = Wrapped(Param * f)
template<class Parameter , class Function >
static BoundarySupportedFunction< ZeroGridFunction< typename Function::FunctionSpaceType, typename Function::GridPartType >, EmptyBoundaryIndicatorType >	Dune::ACFem::operator* (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, EmptyBoundaryIndicatorType > &f_)
	Param * Wrapped(f, Empty) = Wrapped(zero, Empty)
template<class Field , class Parameter , class Function , class Indicator >
static auto	Dune::ACFem::operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(p_.left() *(p_.right() *f_))
	Move scalars out of BinaryParameterExpression.
template<class Left , class Right , class LeftInd , class RightInd >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Left, LeftInd > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asEssBndryFct(asExprArg(f_) *asExprArg(g_))))
	Wrapped(f) * Wrapped(g) = Wrapped(f * g)
template<class Zero , class F , class FInd >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Zero, EmptyBoundaryIndicatorType > &z_, const BoundarySupportedFunction< F, FInd > &f_) -> BoundarySupportedFunction< decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class F , class Zero , class FInd >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< F, FInd > &f_, const BoundarySupportedFunction< Zero, EmptyBoundaryIndicatorType > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(z_, f_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class Left , class Right >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Left, EmptyBoundaryIndicatorType > &z1_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &z2_) -> BoundarySupportedFunction< decltype(zeroProduct(z1_, z2_)), EmptyBoundaryIndicatorType >
	Need to explicitly specialize the zero case, as the the multiplication zero optimiations for grid-function do not take the EmptyBoundaryIndicator into account.
template<class Left , class Right , class RightInd >
static auto	Dune::ACFem::operator* (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> BoundarySupportedFunction< typename EssBndryFct< decltype(asImp(f_) *g_.function())>::Type, typename BoundarySupportedFunction< Right, RightInd >::IndicatorType >
	f * Wrapped(g) = Wrapped(f * g)
template<class Left , class Right >
static auto	Dune::ACFem::operator* (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &g_) -> BoundarySupportedFunction< decltype(zeroProduct(asImp(f_), g_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class ZeroExpression , class Function , class Indicator >
static auto	Dune::ACFem::operator* (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_, const BoundarySupportedFunction< Function, Indicator > &b_) -> BoundarySupportedFunction< decltype(zeroProduct(*z_, b_)), typename BoundarySupportedFunction< Function, Indicator >::IndicatorType >
	zero * Wrapped(g) = Wrapped(zero)
template<class ZeroExpression , class Right >
static auto	Dune::ACFem::operator* (const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &f_, const BoundarySupportedFunction< Right, EmptyBoundaryIndicatorType > &g_) -> BoundarySupportedFunction< decltype(zeroProduct(*f_, g_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class Function , class Wrapped , class Indicator >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Wrapped, Indicator > &b_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> BoundarySupportedFunction< typename EssBndryFct< decltype(b_.function() *asImp(f_))>::Type, typename BoundarySupportedFunction< Wrapped, Indicator >::IndicatorType >
	Wrapped(g) * f = Wrapped(g * f)
template<class Function , class Wrapped >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Wrapped, EmptyBoundaryIndicatorType > &b_, const Fem::Function< typename Function::FunctionSpaceType, Function > &f_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, asImp(f_))), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class ZeroExpression , class Wrapped , class Indicator >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Wrapped, Indicator > &b_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, *z_)), typename BoundarySupportedFunction< Wrapped, Indicator >::IndicatorType >
	Wrapped(g) * zero = Wrapped(zero)
template<class ZeroExpression , class Wrapped >
static auto	Dune::ACFem::operator* (const BoundarySupportedFunction< Wrapped, EmptyBoundaryIndicatorType > &b_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &z_) -> BoundarySupportedFunction< decltype(zeroProduct(b_, *z_)), EmptyBoundaryIndicatorType >
	Zero specialization.
template<class Function , class Indicator >
static BoundarySupportedFunction< Function, Indicator >	Dune::ACFem::operator* (const decltype(oneFunction(std::declval< Function >()))&one, const BoundarySupportedFunction< Function, Indicator > &f_)
	1 * Wrapped(f) = Wrapped(f)
template<class Function , class Indicator >
static BoundarySupportedFunction< Function, Indicator >	Dune::ACFem::operator* (const BoundarySupportedFunction< Function, Indicator > &f_, const decltype(oneFunction(std::declval< Function >()))&one)
	Wrapped(f) * 1 = Wrapped(f)
template<class Left , class Right , class RightInd >
static auto	Dune::ACFem::operator/ (const Fem::Function< typename Left::FunctionSpaceType, Left > &f_, const BoundarySupportedFunction< Right, RightInd > &g_) -> decltype(asBndryFct(asEssBndryFct(f_/asExprArg(g_))))
	f / Wrapped(g) = Wrapped(f / g)
template<class Function , class Indicator >
static auto	Dune::ACFem::operator/ (const typename Function::RangeFieldType &s_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(s_/asExprArg(f_))))
	s / Wrapped(f) = Wrapped(s / f)
template<class Parameter , class Function , class Indicator >
static auto	Dune::ACFem::operator/ (const ParameterInterface< Parameter > &p_, const BoundarySupportedFunction< Function, Indicator > &f_) -> decltype(asBndryFct(asEssBndryFct(asImp(p_)/asExprArg(f_))))
	Param * Wrapped(f) = Wrapped(Param * f)

Detailed Description

Similar to the WrapperExpressionOptimiztation, but rather not an optimization.

The similarity is that we combing BoundarySupportedFunctions by applying the expressions to the wrapped functions and wrap the resulting expression by an appropriate BoundarySupportedFunction. The difference is that otherwise GridFunctionExpression's would not work at all, while for the GridFunctionWrapper the additional operator function are a mere optimization.

What do we need to support?

We do want to support mixed operations in the sense that an unconstrained function combined with a constrained function does not alter the boundary support.

Functions wrapped into BoundarySupportedFunction must already be Grid-Functions.

Function Documentation

operator+() [1/2]

template<class ZeroExpression , class Left , class LeftInd >

static auto Dune::ACFem::operator+ ( const BoundarySupportedFunction< Left, LeftInd > &  f_, const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &  g_  ) -> decltype(asBndryFct(asExprArg(f_) + g_))

inlinestatic

Wrapped(f) + zero = Wrapped(f + zero)

This has to be specialized in order to avoid ambuigities caused by other ZeroGridFunction specializations.

operator+() [2/2]

template<class ZeroExpression , class Right , class RightInd >

static auto Dune::ACFem::operator+ ( const ZeroGridFunctionExpression< typename ZeroExpression::FunctionSpaceType, ZeroExpression > &  f_, const BoundarySupportedFunction< Right, RightInd > &  g_  ) -> decltype(asBndryFct(f_ + asExprArg(g_)))

inlinestatic

zero + Wrapped(g) = Wrapped(zero + g)

This has to be specialized in order to avoid ambuigities caused by other ZeroGridFunction specializations.