functionalexpression.hh

#ifndef __DUNE_ACFEM_FUNCTIONAL_EXPRESSIONS_HH__
#define __DUNE_ACFEM_FUNCTIONAL_EXPRESSIONS_HH__
 
#include "functionalexpressionbase.hh"
#include "../../expressions/parameterexpression.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class UnOp, class Functional>
    class UnaryFunctionalExpression;
 
    template<class UnOp, class Functional>
    class UnaryLocalFunctionalExpression;
 
    template<class BinOp, class LeftFunctionional, class RightFunctionional>
    class BinaryFunctionalExpression;
 
    template<class BinOp, class LeftFunctionional, class RightFunctionional>
    class BinaryLocalFunctionalExpression;
 
    template<class UnOp>
    struct UnaryFunctionalExpressionOperation
    {};
 
    template<>
    struct UnaryFunctionalExpressionOperation<MinusOperation>
    {
      template<class Scalar>
      static Scalar apply(const Scalar& s)
      {
        return -s;
      }
    };
 
    template<>
    struct UnaryFunctionalExpressionOperation<IdentityOperation>
    {
      template<class Scalar>
      static Scalar apply(const Scalar& s)
      {
        return s;
      }
    };
 
    template<class UnOp, class Functional>
    struct UnaryFunctionalExpressionTraits
      : public LinearFunctionalTraitsDefault<UnaryFunctionalExpression<UnOp, Functional>,
                                             UnaryLocalFunctionalExpression<UnOp, Functional> >
    {};
 
    template<class UnOp, class Functional>
    class UnaryFunctionalExpression
      : public DiscreteLinearFunctionalExpression<typename Functional::DiscreteFunctionSpaceType,
                                                  UnaryFunctionalExpressionTraits<UnOp, Functional> >
    {
      typedef UnOp OpType;
      typedef UnaryFunctionalExpression ThisType;
     public:
      typedef typename Functional::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef UnaryFunctionalExpressionTraits<OpType, Functional> TraitsType;
     private:
      typedef DiscreteLinearFunctionalExpression<DiscreteFunctionSpaceType, TraitsType> BaseType;
     public:
      typedef Functional ContainedExpressionType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      UnaryFunctionalExpression(const ContainedExpressionType& phi)
        : BaseType(phi.space()), functional_(phi)
      {}
 
      using BaseType::operator();
      using BaseType::coefficients;
      using BaseType::space;
      using BaseType::localFunctional;
 
      const ContainedExpressionType& containedExpression() const
      {
        return functional_();
      }
 
      std::string name() const
      {
        return OpType::name() + "(" + functional_().name() + ")";
      }
 
     protected:
      ExpressionStorage<ContainedExpressionType> functional_;
    };
 
    template<class UnOp, class Functional>
    class UnaryLocalFunctionalExpression
      : public
    LocalLinearFunctionalDefault<typename Functional::DiscreteFunctionSpaceType,
                                 UnaryFunctionalExpressionTraits<UnOp, Functional> >
    {
      typedef UnOp OpType;
      typedef UnaryFunctionalExpressionOperation<OpType> OperationType;
      typedef UnaryLocalFunctionalExpression ThisType;
     public:
      typedef typename Functional::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef UnaryFunctionalExpressionTraits<OpType, Functional> TraitsType;
      typedef typename TraitsType::GlobalFunctionalType FunctionalType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
     private:
      typedef LocalLinearFunctionalDefault<DiscreteFunctionSpaceType, TraitsType> BaseType;
     protected:
      typedef Functional ContainedFunctionalType;
      typedef typename Functional::LocalFunctionalType ContainedLocalFunctionalType;
     public:
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      UnaryLocalFunctionalExpression(const FunctionalType& expr)
        : BaseType(expr), localContainedFunctional_(expr.containedExpression())
      {}
 
      UnaryLocalFunctionalExpression(const EntityType& entity, const FunctionalType& expr)
        : BaseType(entity, expr),
          localContainedFunctional_(expr.containedExpression().localFunctional(entity))
      {}
 
     public:
      void init(const EntityType& entity)
      {
        localContainedFunctional_.init(entity);
        BaseType::init(entity);
      }
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg)
      {
        return OperationType::apply(localContainedFunctional_(arg));
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        localContainedFunctional_.coefficients(OperationType::apply(c), coeffs);
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs) const
      {
        BaseType::coefficients(coeffs);
      }
 
      using BaseType::functional;
      using BaseType::entity;
 
     protected:
      ContainedLocalFunctionalType localContainedFunctional_;
    };
 
 
 
 
    template<class BinOp>
    struct BinaryFunctionalExpressionOperation
    {};
 
    template<>
    struct BinaryFunctionalExpressionOperation<PlusOperation>
    {
      template<class Field>
      static Field apply(const Field& left, const Field& right)
      {
        return left + right;
      }
 
      template<class Field, class LeftArg, class RightArg, class LocalFunction>
      static void apply(const Field& c, const LeftArg& left, const RightArg& right, LocalFunction& coeffs)
      {
        left.coefficients(c, coeffs);
        right.coefficients(c, coeffs);
      }
 
      template<class Left>
      static std::string leftName(const Left& left)
      {
        return left.name();
      }
 
      template<class Right>
      static std::string rightName(const Right& right)
      {
        return right.name();
      }
    };
 
    template<>
    struct BinaryFunctionalExpressionOperation<MinusOperation>
    {
      template<class Field>
      static Field apply(const Field& left, const Field& right)
      {
        return left - right;
      }
 
      template<class Field, class LeftArg, class RightArg, class LocalFunction>
      static void apply(const Field& c, const LeftArg& left, const RightArg& right, LocalFunction& coeffs)
      {
        left.coefficients(c, coeffs);
        right.coefficients(-c, coeffs);
      }
 
      template<class Left>
      static std::string leftName(const Left& left)
      {
        return left.name();
      }
 
      template<class Right>
      static std::string rightName(const Right& right)
      {
        return right.name();
      }
    };
 
    template<>
    struct BinaryFunctionalExpressionOperation<SMultiplyOperation>
    {
      template<class Field>
      static Field apply(const Field& left, const Field& right)
      {
        return left * right;
      }
 
      template<class Field, class LocalFunctional, class LocalFunction>
      static void apply(const Field& c, const Field& left, const LocalFunctional& phiLoc, LocalFunction& coeffs)
      {
        phiLoc.coefficients(c * left, coeffs);
      }
 
      template<class Field>
      static std::string leftName(const Field& left)
      {
        std::string factorName = std::to_string(parameterValue(left));
        if (ParameterValue<Field>::isParameter) {
          factorName = "P(" + factorName + ")";
        }
        return factorName;
      }
 
      template<class Right>
      static std::string rightName(const Right& right)
      {
        return right.name();
      }
    };
 
    template<class BinOp, class LeftArg, class RightArg>
    struct BinaryFunctionalExpressionTraits
      : public LinearFunctionalTraitsDefault<BinaryFunctionalExpression<BinOp, LeftArg, RightArg>,
                                             BinaryLocalFunctionalExpression<BinOp, LeftArg, RightArg> >
    {};
 
    template<class BinOp, class LeftArg, class RightArg>
    class BinaryFunctionalExpression
      : public DiscreteLinearFunctionalExpression<typename RightArg::DiscreteFunctionSpaceType,
                                                  BinaryFunctionalExpressionTraits<BinOp, LeftArg, RightArg> >
    {
      typedef BinOp OpType;
      typedef BinaryFunctionalExpressionOperation<OpType> OperationType;
      typedef BinaryFunctionalExpression ThisType;
     public:
      typedef typename RightArg::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef BinaryFunctionalExpressionTraits<OpType, LeftArg, RightArg> TraitsType;
     private:
      typedef DiscreteLinearFunctionalExpression<DiscreteFunctionSpaceType, TraitsType> BaseType;
     public:
      typedef LeftArg LeftExpressionType;
      typedef RightArg RightExpressionType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      BinaryFunctionalExpression(const LeftExpressionType& left, const RightExpressionType& right)
        : BaseType(right.space()), left_(left), right_(right)
      {}
 
      using BaseType::operator();
      using BaseType::coefficients;
      using BaseType::space;
      using BaseType::localFunctional;
 
      const LeftExpressionType& leftExpression() const
      {
        return left_();
      }
      const RightExpressionType& rightExpression() const
      {
        return right_();
      }
 
      std::string name() const
      {
        return ("(" +
                OperationType::leftName(left_())
                + " " +
                OpType::name()
                + " " +
                OperationType::rightName(right_())
                + ")");
      }
 
     protected:
      ExpressionStorage<LeftExpressionType> left_;
      ExpressionStorage<RightExpressionType> right_;
    };
 
    template<class BinOp, class LeftArg, class RightArg>
    class BinaryLocalFunctionalExpression
      : public
    LocalLinearFunctionalDefault<typename LeftArg::DiscreteFunctionSpaceType,
                                 BinaryFunctionalExpressionTraits<BinOp, LeftArg, RightArg> >
    {
      typedef BinOp OpType;
      typedef BinaryFunctionalExpressionOperation<OpType> OperationType;
      typedef BinaryLocalFunctionalExpression ThisType;
     public:
      typedef typename LeftArg::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef BinaryFunctionalExpressionTraits<OpType, LeftArg, RightArg> TraitsType;
      typedef typename TraitsType::GlobalFunctionalType FunctionalType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
     private:
      typedef LocalLinearFunctionalDefault<DiscreteFunctionSpaceType, TraitsType> BaseType;
     protected:
      typedef LeftArg LeftExpressionType;
      typedef RightArg RightExpressionType;
      typedef typename LeftArg::LocalFunctionalType LeftLocalFunctionalType;
      typedef typename RightArg::LocalFunctionalType RightLocalFunctionalType;
     public:
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      BinaryLocalFunctionalExpression(const FunctionalType& expr)
        : BaseType(expr),
          leftLocalFunctional_(expr.leftExpression()),
          rightLocalFunctional_(expr.rightExpression())
      {}
 
      BinaryLocalFunctionalExpression(const EntityType& entity, const FunctionalType& expr)
        : BaseType(entity, expr),
          leftLocalFunctional_(expr.leftExpression().localFunctional(entity)),
          rightLocalFunctional_(expr.rightExpression().localFunctional(entity))
      {}
 
     public:
      void init(const EntityType& entity)
      {
        leftLocalFunctional_.init(entity);
        rightLocalFunctional_.init(entity);
        BaseType::init(entity);
      }
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg)
      {
        return OperationType::apply(leftLocalFunctional_(arg), rightLocalFunctional_(arg));
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        OperationType::apply(c, leftLocalFunctional_, rightLocalFunctional_, coeffs);
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs) const
      {
        BaseType::coefficients(coeffs);
      }
 
      using BaseType::functional;
      using BaseType::entity;
 
     protected:
      LeftLocalFunctionalType leftLocalFunctional_;
      RightLocalFunctionalType rightLocalFunctional_;
    };
 
    //
    // S-multiplication by scalars and parameter
 
    // No need to change the Traits stuff
 
    template<class LeftArg, class RightArg>
    class BinaryLocalFunctionalExpression<SMultiplyOperation, LeftArg, RightArg>
      : public
    LocalLinearFunctionalDefault<typename RightArg::DiscreteFunctionSpaceType,
                                 BinaryFunctionalExpressionTraits<SMultiplyOperation, LeftArg, RightArg> >
    {
      typedef SMultiplyOperation OpType;
      typedef BinaryFunctionalExpressionOperation<OpType> OperationType;
      typedef BinaryLocalFunctionalExpression ThisType;
     public:
      typedef typename RightArg::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      typedef BinaryFunctionalExpressionTraits<OpType, LeftArg, RightArg> TraitsType;
      typedef typename TraitsType::GlobalFunctionalType FunctionalType;
      typedef typename TraitsType::LocalFunctionalType LocalFunctionalType;
     private:
      typedef LocalLinearFunctionalDefault<DiscreteFunctionSpaceType, TraitsType> BaseType;
     protected:
      typedef LeftArg LeftExpressionType;
      typedef RightArg RightExpressionType;
      typedef LeftExpressionType FactorType;
      typedef typename RightArg::LocalFunctionalType SubLocalFunctionalType;
     public:
      typedef typename DiscreteFunctionSpaceType::EntityType EntityType;
      typedef typename DiscreteFunctionSpaceType::RangeFieldType FieldType;
      typedef FieldType RangeType;
 
      BinaryLocalFunctionalExpression(const FunctionalType& expr)
        : BaseType(expr),
          scalar_(expr.leftExpression()),
          localFunctional_(expr.rightExpression())
      {}
 
      BinaryLocalFunctionalExpression(const EntityType& entity, const FunctionalType& expr)
        : BaseType(entity, expr),
          scalar_(expr.leftExpression()),
          localFunctional_(expr.rightExpression().localFunctional(entity))
      {}
 
     public:
      void init(const EntityType& entity)
      {
        localFunctional_.init(entity);
        BaseType::init(entity);
      }
 
      template<class LocalFunction>
      RangeType operator()(const LocalFunction& arg)
      {
        return OperationType::apply(RangeType(parameterValue(scalar_)), localFunctional_(arg));
      }
 
      template<class LocalFunction>
      void coefficients(const RangeType& c, LocalFunction& coeffs) const
      {
        OperationType::apply(c, RangeType(parameterValue(scalar_)), localFunctional_, coeffs);
      }
 
      template<class LocalFunction>
      void coefficients(LocalFunction& coeffs) const
      {
        BaseType::coefficients(coeffs);
      }
 
      using BaseType::functional;
      using BaseType::entity;
 
     protected:
      const FactorType& scalar_;
      SubLocalFunctionalType localFunctional_;
    };
 
    //
    //
 
 
 
    // Operator definitions, unary operations
 
    template<class DiscreteFunctionSpace, class Traits>
    UnaryFunctionalExpression<MinusOperation, typename Traits::GlobalFunctionalType>
    operator-(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
    {
      typedef typename Traits::GlobalFunctionalType FunctionalType;
      const FunctionalType& phi(static_cast<const FunctionalType&>(phi_));
 
      typedef
        UnaryFunctionalExpression<MinusOperation, FunctionalType>
        ExpressionType;
 
      return ExpressionType(phi);
    }
 
    template<class DiscreteFunctionSpace, class Traits>
    UnaryFunctionalExpression<IdentityOperation, typename Traits::GlobalFunctionalType>
    operator*(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
    {
      typedef typename Traits::GlobalFunctionalType FunctionalType;
      const FunctionalType& phi(static_cast<const FunctionalType&>(phi_));
 
      typedef
        UnaryFunctionalExpression<IdentityOperation, FunctionalType>
        ExpressionType;
 
      return ExpressionType(phi);
    }
 
    // Operator definitions, binary operations
 
    template<class DiscreteFunctionSpace, class LeftTraits, class RightTraits>
    BinaryFunctionalExpression<PlusOperation,
                               typename LeftTraits::GlobalFunctionalType,
                               typename RightTraits::GlobalFunctionalType>
    operator+(const DiscreteLinearFunctional<DiscreteFunctionSpace, LeftTraits>& left_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, RightTraits>& right_)
    {
      typedef typename LeftTraits::GlobalFunctionalType LeftType;
      typedef typename RightTraits::GlobalFunctionalType RightType;
 
      const LeftType& left(static_cast<const LeftType&>(left_));
      const RightType& right(static_cast<const RightType&>(right_));
 
      typedef
        BinaryFunctionalExpression<PlusOperation, LeftType, RightType>
        ExpressionType;
 
      return ExpressionType(left, right);
    }
 
    template<class DiscreteFunctionSpace, class LeftTraits, class RightTraits>
    BinaryFunctionalExpression<MinusOperation,
                               typename LeftTraits::GlobalFunctionalType,
                               typename RightTraits::GlobalFunctionalType>
    operator-(const DiscreteLinearFunctional<DiscreteFunctionSpace, LeftTraits>& left_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, RightTraits>& right_)
    {
      typedef typename LeftTraits::GlobalFunctionalType LeftType;
      typedef typename RightTraits::GlobalFunctionalType RightType;
 
      const LeftType& left(static_cast<const LeftType&>(left_));
      const RightType& right(static_cast<const RightType&>(right_));
 
      typedef
        BinaryFunctionalExpression<MinusOperation, LeftType, RightType>
        ExpressionType;
 
      return ExpressionType(left, right);
    }
 
    template<class DiscreteFunctionSpace, class LeftTraits, class Functional>
    auto
    operator-(const DiscreteLinearFunctional<DiscreteFunctionSpace, LeftTraits>& left_,
              const UnaryFunctionalExpression<MinusOperation, Functional>& right_)
      -> decltype(asImp(left_) + right_.containedExpression())
    {
      return asImp(left_) + right_.containedExpression();
    }
 
    template<class DiscreteFunctionSpace, class Functional, class RightTraits>
    auto
    operator+(const UnaryFunctionalExpression<MinusOperation, Functional>& left_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, RightTraits>& right_)
      -> decltype(asImp(right_) - left_.containedExpression())
    {
      return asImp(right_) - left_.containedExpression();
    }
 
    template<class DiscreteFunctionSpace, class LeftTraits, class Functional>
    auto
    operator+(const DiscreteLinearFunctional<DiscreteFunctionSpace, LeftTraits>& left_,
              const UnaryFunctionalExpression<MinusOperation, Functional>& right_)
      -> decltype(asImp(left_) - right_.containedExpression())
    {
      return asImp(left_) - right_.containedExpression();
    }
 
    template<class Left, class Right>
    auto
    operator+(const UnaryFunctionalExpression<MinusOperation, Left>& left_,
              const UnaryFunctionalExpression<MinusOperation, Right>& right_)
      -> decltype(-(left_.containedExpression() + right_.containedExpression()))
    {
      return left_.containedExpression() + right_.containedExpression();
    }
 
    //
    // S-Multiplication
 
    template<class DiscreteFunctionSpace, class Traits>
    BinaryFunctionalExpression<SMultiplyOperation,
                               const typename DiscreteFunctionSpace::RangeFieldType,
                               typename Traits::GlobalFunctionalType>
    operator*(const typename DiscreteFunctionSpace::RangeFieldType& left_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& right_)
    {
      typedef typename Traits::GlobalFunctionalType FunctionalType;
      typedef typename DiscreteFunctionSpace::RangeFieldType ScalarType;
 
      typedef
        BinaryFunctionalExpression<SMultiplyOperation,
                                   const ScalarType,
                                   FunctionalType>
        ExpressionType;
 
      const FunctionalType& right(static_cast<const FunctionalType&>(right_));
 
      return ExpressionType(left_, right);
    }
 
    template<class DiscreteFunctionSpace, class Traits>
    auto
    operator*(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& left_,
              const typename DiscreteFunctionSpace::RangeFieldType& right_)
      -> decltype(right_ * asImp(left_))
    {
      return right_ * asImp(left_);
    }
 
    template<class DiscreteFunctionSpace, class Traits>
    auto
    operator/(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& left_,
              const typename DiscreteFunctionSpace::RangeFieldType& right_)
      -> decltype(asImp(left_) * (1.0/right_))
    {
      return asImp(left_) * (1.0/right_);
    }
 
    template<class Parameter, class DiscreteFunctionSpace, class Traits>
    BinaryFunctionalExpression<SMultiplyOperation, Parameter, typename Traits::GlobalFunctionalType>
    operator*(const ParameterInterface<Parameter>& left_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& right_)
    {
      typedef typename Traits::GlobalFunctionalType FunctionalType;
      typedef Parameter ScalarType;
 
      typedef
        BinaryFunctionalExpression<SMultiplyOperation, ScalarType, FunctionalType>
        ExpressionType;
 
      const ScalarType& left(static_cast<const ScalarType&>(left_));
      const FunctionalType& right(static_cast<const FunctionalType&>(right_));
 
      return ExpressionType(left, right);
    }
 
    template<class DiscreteFunctionSpace, class Traits, class Parameter>
    auto
    operator*(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& left_,
              const ParameterInterface<Parameter>& right_)
      -> decltype(asImp(right_) * asImp(left_))
    {
      return asImp(right_) * asImp(left_);
    }
 
    template<class Field, class Functional>
    static inline
    auto operator*(const Field& s,
                   const BinaryFunctionalExpression<SMultiplyOperation, const Field, Functional>& psi)
      -> decltype((s * psi.leftExpression()) * psi.rightExpression())
    {
      return (s * psi.leftExpression()) * psi.rightExpression();
    }
 
    template<class Parameter, class Field, class Functional>
    static inline
    auto operator*(const ParameterInterface<Parameter>& p_,
                   const BinaryFunctionalExpression<SMultiplyOperation, const Field, Functional>& psi)
      -> decltype(psi.leftExpression() * (asImp(p_) * psi.rightExpression()))
    {
      return psi.leftExpression() * (asImp(p_) * psi.rightExpression());
    }
 
    template<class Field, class Parameter, class DiscreteFunctionSpace, class Traits>
    static inline
    auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& p_,
                   const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& psi_)
      -> decltype(p_.left() * (p_.right() * asImp(psi_)))
    {
      return p_.left() * (p_.right() * asImp(psi_));
    }
 
    template<class Parameter, class DiscreteFunctionSpace, class ZeroTraits>
    static inline
    auto
    operator*(const
              BinaryParameterExpression<SMultiplyOperation, typename DiscreteFunctionSpace::RangeFieldType, Parameter>& p,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& phi_)
      -> decltype(*phi_)
    {
      return *phi_;
    }
 
    template<class DiscreteFunctionSpace, class Traits>
    typename Traits::GlobalFunctionalType
    operator*(const DiscreteLinearFunctionalExpression<DiscreteFunctionSpace, Traits>& phi_)
    {
      return phi_.expression();
    }
 
    template<class Functional>
    auto
    operator-(const UnaryFunctionalExpression<MinusOperation, Functional>& phi_)
      -> decltype(*phi_.containedExpression())
    {
      return *phi_.containedExpression();
    }
 
    template<class DiscreteFunctionSpace, class Traits>
    auto
    operator-(const ZeroFunctionalExpression<DiscreteFunctionSpace, Traits>& phi_)
      -> decltype(*phi_)
    {
      return *phi_;
    }
 
    template<class DiscreteFunctionSpace, class Traits, class ZeroTraits>
    auto
    operator+(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z_)
      -> decltype(*asImp(phi_))
    {
      return *asImp(phi_);
    }
 
    template<class DiscreteFunctionSpace, class Traits, class ZeroTraits>
    auto
    operator+(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
      -> decltype(*asImp(phi_))
    {
      return *asImp(phi_);
    }
 
    template<class DiscreteFunctionSpace, class ZeroTraits1, class ZeroTraits2>
    ZeroFunctional<DiscreteFunctionSpace>
    operator+(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits1>& left_,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits2>& right_)
    {
      return ZeroFunctional<DiscreteFunctionSpace>(left_.space());
    }
 
    template<class DiscreteFunctionSpace, class Traits, class ZeroTraits>
    auto
    operator-(const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z_)
      -> decltype(*asImp(phi_))
    {
      return *asImp(phi_);
    }
 
    template<class DiscreteFunctionSpace, class Traits, class ZeroTraits>
    auto
    operator-(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z_,
              const DiscreteLinearFunctional<DiscreteFunctionSpace, Traits>& phi_)
      -> decltype(-asImp(phi_))
    {
      return -asImp(phi_);
    }
 
    template<class DiscreteFunctionSpace, class ZeroTraits1, class ZeroTraits2>
    ZeroFunctional<DiscreteFunctionSpace>
    operator-(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits1>& left_,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits2>& right_)
    {
      return ZeroFunctional<DiscreteFunctionSpace>(left_.space());
    }
 
    template<class DiscreteFunctionSpace, class ZeroTraits>
    auto
    operator*(const typename DiscreteFunctionSpace::RangeFieldType& s,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z)
      -> decltype(*z)
    {
      return *z;
    }
 
    template<class DiscreteFunctionSpace, class ZeroTraits>
    auto
    operator*(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z,
              const typename DiscreteFunctionSpace::RangeFieldType& s)
      -> decltype(*z)
    {
      return *z;
    }
 
    template<class Parameter, class DiscreteFunctionSpace, class ZeroTraits>
    auto
    operator*(const ParameterInterface<Parameter>& p,
              const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z)
      -> decltype(*z)
    {
      return *z;
    }
 
    template<class Parameter, class DiscreteFunctionSpace, class ZeroTraits>
    auto
    operator*(const ZeroFunctionalExpression<DiscreteFunctionSpace, ZeroTraits>& z,
              const ParameterInterface<Parameter>& p)
      -> decltype(*z)
    {
      return *z;
    }
 
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_FUNCTIONAL_EXPRESSIONS_HH__