parameterexpression.hh

Go to the documentation of this file.

 
#ifndef __DUNE_ACFEM_PARAMETER_EXPRESSION_HH__
#define __DUNE_ACFEM_PARAMETER_EXPRESSION_HH__
 
#include "../expressions/expressionoperations.hh"
#include "../expressions/parameteroperations.hh"
#include "../expressions/parameterinterface.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class ExpressionImp>
    class ParameterExpression
      : public DefaultParameter<ExpressionImp>,
        public ExpressionTemplate<ExpressionImp>
    {};
 
    template<class UnOp, class Parameter>
    class UnaryParameterExpression;
 
    template<class BinOp, class LeftParameter, class RightParameter>
    class BinaryParameterExpression;
 
    template<class UnOp, class Parameter>
    class UnaryParameterExpression
      : public ParameterExpression<UnaryParameterExpression<UnOp, Parameter> >
    {
      typedef UnaryParameterExpression ThisType;
      typedef Parameter ArgumentParameterType;
      typedef UnaryParameterOperation<UnOp> OperationType;
      typedef ParameterTraits<ThisType> TraitsType;
     public:
      typedef typename TraitsType::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      UnaryParameterExpression(const ArgumentParameterType& parameter)
        : parameter_(parameter)
      {}
 
      ValueType value() const {
        ValueType result;
 
        OperationType::evaluate(parameter_().value(), result);
        return result;
      }
 
     protected:
      ExpressionStorage<Parameter> parameter_;
    };
 
    template<class UnOp, class Parameter>
    struct ParameterTraits<UnaryParameterExpression<UnOp, Parameter> >
    {
      typedef typename UnaryExpressionTraits<UnOp, typename Parameter::ValueType>::ResultType ResultType;
      typedef typename ParameterSpaceTraits<ResultType>::ParameterSpaceType ParameterSpaceType;
    };
 
    template<class BinOp, class LeftParameter, class RightParameter>
    class BinaryParameterExpression
      : public ParameterExpression<BinaryParameterExpression<BinOp, LeftParameter, RightParameter> >
    {
      typedef BinaryParameterExpression ThisType;
      typedef LeftParameter LeftParameterType;
      typedef RightParameter RightParameterType;
      typedef BinaryParameterOperation<BinOp> OperationType;
      typedef ParameterTraits<ThisType> TraitsType;
     public:
      typedef typename TraitsType::ParameterSpaceType ParameterSpaceType;
      typedef typename ParameterSpaceType::ScalarParameterSpaceType ScalarParameterSpaceType;
      enum { dimension = ParameterSpaceType::dimension };
      typedef typename ParameterSpaceType::FieldType FieldType;
      typedef typename ParameterSpaceType::ValueType ValueType;
 
      BinaryParameterExpression(const LeftParameterType& left, const RightParameterType& right)
        : left_(left), right_(right)
      {}
 
      ValueType value() const {
        ValueType result;
 
        OperationType::evaluate(parameterValue(left_()), parameterValue(right_()), result);
        return result;
      }
 
      const LeftParameter& left() const
      {
        return left_();
      }
 
      const RightParameter& right() const
      {
        return right_();
      }
 
     protected:
      ExpressionStorage<LeftParameter> left_;
      ExpressionStorage<RightParameter> right_;
    };
 
    template<class BinOp, class LeftParameter, class RightParameter>
    struct ParameterTraits<class BinaryParameterExpression<BinOp, LeftParameter, RightParameter> >
    {
     private:
      // The recursive to ParameterTraits seems too complicated but
      // hacks also the case where one of the parameters is actually
      // just a scalar or some other data type, in which case the
      // ValueType will simply return the template argument as
      // parameter type.
      typedef typename ParameterValue<LeftParameter>::ValueType LeftValueType;
      typedef typename ParameterValue<RightParameter>::ValueType RightValueType;
     public:
      typedef typename BinaryExpressionTraits<BinOp, LeftValueType, RightValueType>::ResultType ResultType;
      typedef typename ParameterSpaceTraits<ResultType>::ParameterSpaceType ParameterSpaceType;
    };
 
    // unary minus
    template<class Parameter>
    UnaryParameterExpression<MinusOperation, Parameter>
    operator-(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<MinusOperation, Parameter> ExpressionType;
      const Parameter& param_(static_cast<const Parameter&>(param));
 
      return ExpressionType(param_);
    }
 
    // cos
    template<class Parameter>
    UnaryParameterExpression<CosOperation, Parameter>
    cos(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<CosOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // sin
    template<class Parameter>
    UnaryParameterExpression<SinOperation, Parameter>
    sin(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<SinOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // tan
    template<class Parameter>
    UnaryParameterExpression<TanOperation, Parameter>
    tan(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<TanOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // atan
    template<class Parameter>
    UnaryParameterExpression<AtanOperation, Parameter>
    atan(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<AtanOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // acos
    template<class Parameter>
    UnaryParameterExpression<AcosOperation, Parameter>
    acos(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<AcosOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // asin
    template<class Parameter>
    UnaryParameterExpression<AsinOperation, Parameter>
    asin(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<AsinOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // sqrt
    template<class Parameter>
    UnaryParameterExpression<SqrtOperation, Parameter>
    sqrt(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<SqrtOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // exp
    template<class Parameter>
    UnaryParameterExpression<ExpOperation, Parameter>
    exp(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<ExpOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // sqr (component-wise)
    template<class Parameter>
    UnaryParameterExpression<SquareOperation, Parameter>
    sqr(const ParameterInterface<Parameter>& param)
    {
      typedef UnaryParameterExpression<SquareOperation, Parameter> ExpressionType;
      const Parameter& param_(asImp(param));
 
      return ExpressionType(param_);
    }
 
    // plus
    template<class Left, class Right>
    BinaryParameterExpression<PlusOperation, Left, Right>
    operator+(const ParameterInterface<Left>& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<PlusOperation, Left, Right> ExpressionType;
      const Left& left_(static_cast<const Left&>(left));
      const Right& right_(static_cast<const Right&>(right));
 
      return ExpressionType(left_, right_);
    }
 
    template<class Right>
    BinaryParameterExpression<PlusOperation, typename Right::ValueType, Right>
    operator+(const typename Right::ValueType& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<PlusOperation, typename Right::ValueType, Right> ExpressionType;
      const Right& right_(static_cast<const Right&>(right));
 
      return ExpressionType(left, right_);
    }
 
    template<class Left>
    BinaryParameterExpression<PlusOperation, Left, typename Left::ValueType>
    operator+(const ParameterInterface<Left>& left,
              const typename Left::ValueType& right)
    {
      typedef BinaryParameterExpression<PlusOperation, Left, typename Left::ValueType> ExpressionType;
      const Left& left_(static_cast<const Left&>(left));
 
      return ExpressionType(left_, right);
    }
 
    template<class Left, class Right>
    BinaryParameterExpression<MinusOperation, Left, Right>
    operator-(const ParameterInterface<Left>& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<MinusOperation, Left, Right> ExpressionType;
      const Left& left_(static_cast<const Left&>(left));
      const Right& right_(static_cast<const Right&>(right));
 
      return ExpressionType(left_, right_);
    }
 
    template<class Right>
    BinaryParameterExpression<MinusOperation, typename Right::ValueType, Right>
    operator-(const typename Right::ValueType& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<MinusOperation, typename Right::ValueType, Right> ExpressionType;
      const Right& right_(static_cast<const Right&>(right));
 
      return ExpressionType(left, right_);
    }
 
    template<class Left>
    BinaryParameterExpression<MinusOperation, Left, typename Left::ValueType>
    operator-(const ParameterInterface<Left>& left,
              const typename Left::ValueType& right)
    {
      typedef BinaryParameterExpression<MinusOperation, Left, typename Left::ValueType> ExpressionType;
      const Left& left_(static_cast<const Left&>(left));
 
      return ExpressionType(left_, right);
    }
 
    template<class Left, class Right>
    BinaryParameterExpression<MultiplyOperation, Left, Right>
    operator*(const ParameterInterface<Left>& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<MultiplyOperation, Left, Right> ExpressionType;
      const Left& left_(static_cast<const Left&>(left));
      const Right& right_(static_cast<const Right&>(right));
 
      return ExpressionType(left_, right_);
    }
 
    template<class Right>
    BinaryParameterExpression<MultiplyOperation, typename Right::ValueType, Right>
    operator*(const typename Right::ValueType& left,
              const ParameterInterface<Right>& right)
    {
      typedef BinaryParameterExpression<MultiplyOperation, typename Right::ValueType, Right> ExpressionType;
      const Right& right_ = static_cast<const Right &>(right);
 
      return ExpressionType(left, right_);
    }
 
    template<class Left>
    auto operator*(const ParameterInterface<Left>& left,
                   const typename Left::ValueType& right)
      -> decltype(right * asImp(left))
    {
      return right * asImp(left);
    }
 
    template<class Right>
    BinaryParameterExpression<SMultiplyOperation, typename FieldTraits<typename Right::ValueType>::field_type, Right>
    operator*(const typename FieldTraits<typename Right::ValueType>::field_type& left,
              const ParameterInterface<Right>& right)
    {
      typedef typename FieldTraits<typename Right::ValueType>::field_type FieldType;
      typedef BinaryParameterExpression<SMultiplyOperation, FieldType, Right> ExpressionType;
      const Right& right_ = static_cast<const Right &>(right);
 
      return ExpressionType(left, right_);
    }
 
    template<class Left>
    auto operator*(const ParameterInterface<Left>& left,
                   const typename FieldTraits<typename Left::ValueType>::field_type& right)
      -> decltype(right * asImp(left))
    {
      return right * asImp(left);
    }
 
    template<class Field, class Parameter>
    static inline
    auto operator*(const Field& s_,
                   const BinaryParameterExpression<SMultiplyOperation, Field, Parameter>& P_)
      -> decltype((s_ * P_.left()) * P_.right())
    {
      return (s_ * P_.left()) * P_.right();
    }
 
    template<class Field, class Parameter1, class Parameter2>
    static inline
    auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter1>& P1_,
                   const ParameterInterface<Parameter2>& P2_)
      -> decltype(P1_.left() * (P1_.right() * asImp(P2_)))
    {
      return P1_.left() * (P1_.right() * asImp(P2_));
    }
 
    template<class Field, class Parameter1, class Parameter2>
    static inline
    auto operator*(const ParameterInterface<Parameter1>& P1_,
                   const BinaryParameterExpression<SMultiplyOperation, Field, Parameter2>& P2_)
 
      -> decltype(P2_.left() * (asImp(P1_) * P2_.right()))
    {
      return P2_.left() * (asImp(P1_) * P2_.right());
    }
 
    template<class Field, class Parameter1, class Parameter2>
    static inline
    auto operator*(const BinaryParameterExpression<SMultiplyOperation, Field, Parameter1>& P1_,
                   const BinaryParameterExpression<SMultiplyOperation, Field, Parameter2>& P2_)
 
      -> decltype((P2_.left() * P2_.left()) * (P1_.right() * P2_.right()))
    {
      return (P2_.left() * P2_.left()) * (P1_.right() * P2_.right());
    }
 
 
 
  } //ACFem
 
} // Dune
 
 
#endif // __DUNE_ACFEM_PARAMETER_EXPRESSION_HH__