FunctionalExpressions

Simple algebraic expressions with linear functionals. More...

Modules
	FunctionalExpressionOptimizations
	Perform the usual vector-space optimizations (0+x=x and the like).

Classes
class	Dune::ACFem::BinaryFunctionalExpression< BinOp, LeftArg, RightArg >
	Binary functional expression. More...
struct	Dune::ACFem::UnaryFunctionalExpressionTraits< UnOp, Functional >
	"No-storage", traits, stuff lives on the stack More...
struct	Dune::ACFem::BinaryFunctionalExpressionTraits< BinOp, LeftArg, RightArg >
	"No-storage", traits, stuff lives on the stack More...
class	Dune::ACFem::BinaryLocalFunctionalExpression< SMultiplyOperation, LeftArg, RightArg >
	Implement S-multiplication by scalars and parameters from the left, multiplication from the right will be redirected to this class. More...

Functions
template<class DiscreteFunctionSpace , class Traits >
UnaryFunctionalExpression< IdentityOperation, typename Traits::GlobalFunctionalType >	Dune::ACFem::operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_)
	Identity expression, in order to wrap non-expressions into expressions.
template<class DiscreteFunctionSpace , class LeftTraits , class RightTraits >
BinaryFunctionalExpression< PlusOperation, typename LeftTraits::GlobalFunctionalType, typename RightTraits::GlobalFunctionalType >	Dune::ACFem::operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_)
	Binary plus.
template<class DiscreteFunctionSpace , class LeftTraits , class RightTraits >
BinaryFunctionalExpression< MinusOperation, typename LeftTraits::GlobalFunctionalType, typename RightTraits::GlobalFunctionalType >	Dune::ACFem::operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_)
	Binary minus.
template<class DiscreteFunctionSpace , class LeftTraits , class Functional >
auto	Dune::ACFem::operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const UnaryFunctionalExpression< MinusOperation, Functional > &right_) -> decltype(asImp(left_)+right_.containedExpression())
	Reduce a - (-b) to a + b.
template<class DiscreteFunctionSpace , class Functional , class RightTraits >
auto	Dune::ACFem::operator+ (const UnaryFunctionalExpression< MinusOperation, Functional > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, RightTraits > &right_) -> decltype(asImp(right_) - left_.containedExpression())
	Reduce -a + b to b - a.
template<class DiscreteFunctionSpace , class LeftTraits , class Functional >
auto	Dune::ACFem::operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, LeftTraits > &left_, const UnaryFunctionalExpression< MinusOperation, Functional > &right_) -> decltype(asImp(left_) - right_.containedExpression())
	Reduce a + (-b) to a - b.
template<class Left , class Right >
auto	Dune::ACFem::operator+ (const UnaryFunctionalExpression< MinusOperation, Left > &left_, const UnaryFunctionalExpression< MinusOperation, Right > &right_) -> decltype(-(left_.containedExpression()+right_.containedExpression()))
	Reduce -a + (-b) to -(b + a)
template<class DiscreteFunctionSpace , class Traits >
BinaryFunctionalExpression< SMultiplyOperation, const typename DiscreteFunctionSpace::RangeFieldType, typename Traits::GlobalFunctionalType >	Dune::ACFem::operator* (const typename DiscreteFunctionSpace::RangeFieldType &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &right_)
	S-Multiplication from the left with scalars.
template<class DiscreteFunctionSpace , class Traits >
auto	Dune::ACFem::operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const typename DiscreteFunctionSpace::RangeFieldType &right_) -> decltype(right_ *asImp(left_))
	S-Multiplication from the right with scalars.
template<class DiscreteFunctionSpace , class Traits >
auto	Dune::ACFem::operator/ (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const typename DiscreteFunctionSpace::RangeFieldType &right_) -> decltype(asImp(left_) *(1.0/right_))
	Division by scalars is S-Multiplication reciprocal scalar.
template<class Parameter , class DiscreteFunctionSpace , class Traits >
BinaryFunctionalExpression< SMultiplyOperation, Parameter, typename Traits::GlobalFunctionalType >	Dune::ACFem::operator* (const ParameterInterface< Parameter > &left_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &right_)
	S-Multiplication from the left with parameters.
template<class DiscreteFunctionSpace , class Traits , class Parameter >
auto	Dune::ACFem::operator* (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &left_, const ParameterInterface< Parameter > &right_) -> decltype(asImp(right_) *asImp(left_))
	S-Multiplication from the right with parameters.

Detailed Description

Simple algebraic expressions with linear functionals.

Some care has been taken to optimize some common redundant cases away at the template level (e.g. (-a + b) = b - a), -(-a) = a and the like. Nevertheless – as all convenient expression template stuff – this has to be used with care in order not to produce inefficient code. For common stuff like scaling L2-functionals, adding boundary L2-functionals to bulk L2-functionals it should be sufficient and efficient enough.

Note that the special case of adding and subtracting the ZeroFunctional is also handled efficiently, for the sake of ModelExpressions.