FunctionalExpressionOptimizations

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

Functions
template<class Field , class Functional >
static auto	Dune::ACFem::operator* (const Field &s, const BinaryFunctionalExpression< SMultiplyOperation, const Field, Functional > &psi) -> decltype((s *psi.leftExpression()) *psi.rightExpression())
	Fold s1 * (s2 * psi) into (s1 * s2) * psi.
template<class Parameter , class Field , class Functional >
static auto	Dune::ACFem::operator* (const ParameterInterface< Parameter > &p_, const BinaryFunctionalExpression< SMultiplyOperation, const Field, Functional > &psi) -> decltype(psi.leftExpression() *(asImp(p_) *psi.rightExpression()))
	Move scalars left-most.
template<class Field , class Parameter , class DiscreteFunctionSpace , class Traits >
static auto	Dune::ACFem::operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &psi_) -> decltype(p_.left() *(p_.right() *asImp(psi_)))
	Move scalars out of s-mult expression with parameters.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
static auto	Dune::ACFem::operator* (const BinaryParameterExpression< SMultiplyOperation, typename DiscreteFunctionSpace::RangeFieldType, Parameter > &p, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &phi_) -> decltype(*phi_)
	Avoid ambuigities with zero optimization.
template<class DiscreteFunctionSpace , class Traits >
Traits::GlobalFunctionalType	Dune::ACFem::operator* (const DiscreteLinearFunctionalExpression< DiscreteFunctionSpace, Traits > &phi_)
	Avoid double identity wrapping.
template<class Functional >
auto	Dune::ACFem::operator- (const UnaryFunctionalExpression< MinusOperation, Functional > &phi_) -> decltype(*phi_.containedExpression())
	-(-Phi) = Phi. More...
template<class DiscreteFunctionSpace , class Traits >
auto	Dune::ACFem::operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, Traits > &phi_) -> decltype(*phi_)
	-ZeroFunctional == ZeroFunctional
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	Dune::ACFem::operator+ (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_) -> decltype(*asImp(phi_))
	DiscreteLinearFunctional + ZeroFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	Dune::ACFem::operator+ (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(*asImp(phi_))
	ZeroFunctional + DiscreteLinearFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class ZeroTraits1 , class ZeroTraits2 >
ZeroFunctional< DiscreteFunctionSpace >	Dune::ACFem::operator+ (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits1 > &left_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits2 > &right_)
	Finally Zero + Zero = Zero.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	Dune::ACFem::operator- (const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_) -> decltype(*asImp(phi_))
	DiscreteLinearFunctional - ZeroFunctional = DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class Traits , class ZeroTraits >
auto	Dune::ACFem::operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z_, const DiscreteLinearFunctional< DiscreteFunctionSpace, Traits > &phi_) -> decltype(-asImp(phi_))
	ZeroFunctional - DiscreteLinearFunctional = -DiscreteLinearFunctional.
template<class DiscreteFunctionSpace , class ZeroTraits1 , class ZeroTraits2 >
ZeroFunctional< DiscreteFunctionSpace >	Dune::ACFem::operator- (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits1 > &left_, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits2 > &right_)
	Finally Zero - Zero = Zero.
template<class DiscreteFunctionSpace , class ZeroTraits >
auto	Dune::ACFem::operator* (const typename DiscreteFunctionSpace::RangeFieldType &s, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z) -> decltype(*z)
	s * ZeroFunctional = ZeroFunctional, but we have to wrap it (really?)
template<class DiscreteFunctionSpace , class ZeroTraits >
auto	Dune::ACFem::operator* (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z, const typename DiscreteFunctionSpace::RangeFieldType &s) -> decltype(*z)
	ZeroFunctional * s = s * ZeroFunctional.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
auto	Dune::ACFem::operator* (const ParameterInterface< Parameter > &p, const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z) -> decltype(*z)
	ParameterInterface * ZeroFunctional = ZeroFunctional, but wrap zero.
template<class Parameter , class DiscreteFunctionSpace , class ZeroTraits >
auto	Dune::ACFem::operator* (const ZeroFunctionalExpression< DiscreteFunctionSpace, ZeroTraits > &z, const ParameterInterface< Parameter > &p) -> decltype(*z)
	ZeroFunctional * ParameterInterface = ZeroFunctional.

Detailed Description

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

Function Documentation

operator-()

template<class Functional >

auto Dune::ACFem::operator-

(

const UnaryFunctionalExpression< MinusOperation, Functional > &

phi_

)

-> decltype(*phi_.containedExpression())

-(-Phi) = Phi.

Replace any double unary minus expression by either the contained expression, or if the contained expression is not itself an expression template, wrap it into one identity expression.