DUNE-ACFEM (2.5.1)

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.

Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (Mar 27, 23:31, 2024)