OperatorPartsExpressionOptimizations

Collapse the usual "zero" expressions into more simpler ones. More...

Functions
template<class Expression >
Expression	Dune::ACFem::operator* (const OperatorPartsExpression< Expression > &op_)
	Avoid double identity wrapping.
template<class Operand >
static auto	Dune::ACFem::operator* (const typename Operand::RangeFieldType &s_, const BinaryOperatorPartsExpression< SMultiplyOperation, typename Operand::RangeFieldType, Operand > &op_) -> decltype((s_ *op_.scalar()) *op_.operand())
	Fold s * (s * op) into (s*s) * op.
template<class Parameter , class Operand >
static auto	Dune::ACFem::operator* (const ParameterInterface< Parameter > &p_, const OperatorPartsInterface< BinaryOperatorPartsExpression< SMultiplyOperation, typename Operand::RangeFieldType, Operand > > &op_) -> decltype(asImp(op_).scalar() *(asImp(p_) *asImp(op_).operand()))
	Move sclars left-most.
template<class Field , class Parameter , class Operand >
static auto	Dune::ACFem::operator* (const BinaryParameterExpression< SMultiplyOperation, Field, Parameter > &p_, const OperatorPartsInterface< Operand > &op_) -> decltype(p_.left() *(p_.right() *asImp(op_)))
	Move scalars out of BinaryParameterExpression.
template<class Function , class Field , class Operand >
static auto	Dune::ACFem::operator* (const Fem::Function< typename Function::FunctionSpaceType, Function > &f_, const BinaryOperatorPartsExpression< SMultiplyOperation, Field, Operand > &op_) -> decltype(op_.scalar() *(asImp(f_) *op_.operand()))
	Move sclars left-most.
template<class Field , class Function , class Operand >
static auto	Dune::ACFem::operator* (const BinaryGridFunctionExpression< SMultiplyOperation, Field, Function > &f_, const OperatorPartsInterface< Operand > &op_) -> decltype(f_.scalar() *(f_.function() *asImp(op_)))
	Move scalars out of BinaryGridFunctionExpression.
template<class Operand >
auto	Dune::ACFem::operator- (const UnaryOperatorPartsExpression< MinusOperation, Operand > &op_) -> decltype(*op_.containedExpression())
	-(-Operand) = Operand More...
template<class Operand >
auto	Dune::ACFem::operator+ (const OperatorPartsInterface< Operand > &op, const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z) -> decltype(*asImp(op))
	Operand + Zero = Operand.
template<class Operand >
auto	Dune::ACFem::operator+ (const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z, const OperatorPartsInterface< Operand > &op) -> decltype(*asImp(op))
	Zero + Operand = Operand.
template<class FunctionSpace >
auto	Dune::ACFem::operator+ (const ZeroOperatorParts< FunctionSpace > &z1, const ZeroOperatorParts< FunctionSpace > &z2) -> decltype(*z1)
	Zero + Zero = Zero.
template<class Operand >
auto	Dune::ACFem::operator- (const OperatorPartsInterface< Operand > &op, const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z) -> decltype(*asImp(op))
	Operand - Zero = Operand.
template<class Operand >
auto	Dune::ACFem::operator- (const ZeroOperatorParts< typename Operand::FunctionSpaceType > &z, const OperatorPartsInterface< Operand > &op) -> decltype(-op)
	Zero - Operand = -Operand.
template<class FunctionSpace >
auto	Dune::ACFem::operator- (const ZeroOperatorParts< FunctionSpace > &z1, const ZeroOperatorParts< FunctionSpace > &z2) -> decltype(*z1)
	Zero - Zero = Zero.
template<class FunctionSpace >
auto	Dune::ACFem::operator* (const typename FunctionSpace::RangeFieldType &s_, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	s * Zero = Zero
template<class FunctionSpace >
auto	Dune::ACFem::operator* (const ZeroOperatorParts< FunctionSpace > &z, const typename FunctionSpace::RangeFieldType &s) -> decltype(*z)
	Zero * s = Zero.
template<class Parameter , class FunctionSpace >
auto	Dune::ACFem::operator* (const ParameterInterface< Parameter > &s, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	Parameter * Zero = Zero.
template<class Parameter , class FunctionSpace >
auto	Dune::ACFem::operator* (const ZeroOperatorParts< FunctionSpace > &z, const ParameterInterface< Parameter > &s) -> decltype(*z)
	Zero * Parameter = Zero.
template<class Function , class ScalarSpace , class FunctionSpace >
auto	Dune::ACFem::operator* (const Fem::Function< ScalarSpace, Function > &f, const ZeroOperatorParts< FunctionSpace > &z) -> decltype(*z)
	Function * Zero = Zero.
template<class Function , class ScalarSpace , class FunctionSpace >
auto	Dune::ACFem::operator* (const ZeroOperatorParts< FunctionSpace > &z, const Fem::Function< ScalarSpace, Function > &f) -> decltype(*z)
	Zero * Function = Zero.

Detailed Description

Collapse the usual "zero" expressions into more simpler ones.

Function Documentation

operator-()

template<class Operand >

auto Dune::ACFem::operator-

(

const UnaryOperatorPartsExpression< MinusOperation, Operand > &

op_

)

-> decltype(*op_.containedExpression())

-(-Operand) = Operand

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.