expressionoperations.hh

Go to the documentation of this file.

 
#ifndef __EXPRESSION_OPERATIONS_HH__
#define __EXPRESSION_OPERATIONS_HH__
 
namespace Dune
{
 
  namespace ACFem
  {
 
    template<class ExpressionImp>
    struct ExpressionTemplate
    {
      typedef ExpressionImp ExpressionType;
 
      const ExpressionType& expression() const
      {
        return static_cast<const ExpressionType&>(*this);
      }
 
      ExpressionType& expression()
      {
        return static_cast<ExpressionType&>(*this);
      }
 
      ExpressionType operator*() const
      {
        return expression();
      }
    };
 
    template<class Interface, class Implementation>
    const Implementation& asImp(const Fem::BartonNackmanInterface<Interface, Implementation>& arg)
    {
      return static_cast<const Implementation&>(arg);
    }
 
    template<class SomeThing>
    struct ExpressionReferenceStorage
    {
      typedef SomeThing ObjectType;
 
      ExpressionReferenceStorage(const ObjectType& thing)
        : object_(thing)
      {}
 
      template<class Other>
      ExpressionReferenceStorage(const Other& other)
        : object_(static_cast<const ObjectType&>(other)) {}
 
      ExpressionReferenceStorage()
        : object_(0)
      {}
 
      const ObjectType& operator()() const {
        return object_;
      }
 
     private:
      const ObjectType& object_;
    };
 
    template<class SomeThing>
    struct ExpressionCopyStorage
    {
      typedef SomeThing ObjectType;
 
      ExpressionCopyStorage(const ObjectType& thing) : object_(thing) {}
 
      template<class Other>
      ExpressionCopyStorage(const Other& other) : object_(static_cast<const ObjectType&>(other)) {}
 
      const ObjectType& operator()() const {
        return object_;
      }
 
     private:
      ObjectType object_;
    };
 
    template<class SomeThing>
    struct ExpressionStorage
      : public std::conditional<std::is_base_of<ExpressionTemplate<SomeThing>, SomeThing>::value,
                                ExpressionCopyStorage<SomeThing>,
                                ExpressionReferenceStorage<SomeThing> >::type
    {
      typedef SomeThing ObjectType;
      typedef typename
      std::conditional<
        std::is_base_of<ExpressionTemplate<ObjectType>, ObjectType>::value,
        ExpressionCopyStorage<ObjectType>,
        ExpressionReferenceStorage<ObjectType> >::type
      BaseType;
 
      // inherit the constructors from the base class.
      using BaseType::BaseType;
 
     private:
      // some potential to shoot yourself into your own feet, add some
      // static asserts here in order to be sure that the things
      // happen that we want to happen
 
      enum {
        isExpression = std::is_base_of<ExpressionTemplate<ObjectType>, ObjectType>::value,
        isCopyStorage = std::is_same<BaseType, ExpressionCopyStorage<ObjectType> >::value,
        isReferenceStorage = std::is_same<BaseType, ExpressionReferenceStorage<ObjectType> >::value
      };
      // comment out in order to trigger an error for anything copied
      //static_assert(isCopyStorage, "I am copied");
      // comment out in order to trigger an error for anything not copied
      //static_assert(isReferenceStorage, "I am copied");
 
      // do a consistency check
      static_assert(!isExpression || isCopyStorage, "expressions should be stored as copies");
      static_assert(isExpression || isReferenceStorage, "non-expressions should not be copied");
    };
 
    template<>
    struct ExpressionStorage<double>
      : public ExpressionCopyStorage<double>
    {
     protected:
      typedef ExpressionCopyStorage<double> BaseType;
     public:
      typedef double ObjectType;
 
      using BaseType::BaseType;
    };
 
    template<>
    struct ExpressionStorage<const double>
      : public ExpressionCopyStorage<double>
    {
     protected:
      typedef ExpressionCopyStorage<double> BaseType;
     public:
      typedef double ObjectType;
 
      using BaseType::BaseType;
    };
 
 
    struct PlusOperation
    {
      static std::string name()
      {
        return "+";
      }
    };
 
    struct MinusOperation
    {
      static std::string name()
      {
        return "-";
      }
    };
 
    struct MultiplyOperation
    {
      static std::string name()
      {
        return "*";
      }
    };
 
    struct SMultiplyOperation
    {
      static std::string name()
      {
        return "*";
      }
    };
 
    struct MutableSMultiplyOperation
    {
      static std::string name()
      {
        return "& *";
      }
    };
 
    struct InvertOperation
    {
      static std::string name()
      {
        return "1.0/";
      }
    };
 
    struct IdentityOperation
    {
      static std::string name()
      {
        return "Id";
      }
    };
 
    struct ExpOperation
    {
      static std::string name()
      {
        return "exp";
      }
    };
 
    struct LogOperation
    {
      static std::string name()
      {
        return "log";
      }
    };
 
    struct SqrtOperation
    {
      static std::string name()
      {
        return "sqrt";
      }
    };
 
    struct SquareOperation
    {
      static std::string name()
      {
        return "sqr";
      }
    };
 
    struct SinOperation
    {
      static std::string name()
      {
        return "sin";
      }
    };
 
    struct CosOperation
    {
      static std::string name()
      {
        return "cos";
      }
    };
 
    struct TanOperation
    {
      static std::string name()
      {
        return "tan";
      }
    };
 
    struct AtanOperation
    {
      static std::string name()
      {
        return "atan";
      }
    };
 
    struct AsinOperation
    {
      static std::string name()
      {
        return "asin";
      }
    };
 
    struct AcosOperation
    {
      static std::string name()
      {
        return "acos";
      }
    };
 
    template<class Op>
    std::string operationName(const Op&, const std::string& arg)
    {
      return Op::name() + "(" + arg + ")";
    }
 
    template<class Op>
    std::string operationName(const Op&, const std::string& left, const std::string& right)
    {
      return "(" + left + " " + Op::name() + " " + right + ")";
    }
 
 
    template<class ExpressionImpl>
    struct ZeroExpression
      : public ExpressionTemplate<ExpressionImpl>
    {};
 
    template<class ExpressionImpl>
    struct NonZeroExpression
      : public ExpressionTemplate<ExpressionImpl>
    {};
 
    template<class ExpressionImpl>
    struct OneExpression
      : public ExpressionTemplate<ExpressionImpl>
    {};
 
    template<class ExpressionImpl>
    struct DefaultExpressionTraits
    {
      typedef ExpressionImpl ExpressionType;
      static const bool isZero = std::is_base_of<ZeroExpression<ExpressionType>, ExpressionType>::value;
      static const bool isNonZero = std::is_base_of<NonZeroExpression<ExpressionType>, ExpressionType>::value;
      static const bool isOne = std::is_base_of<OneExpression<ExpressionType>, ExpressionType>::value;
    };
 
    template<class Expression>
    struct ExpressionTraits
      : public DefaultExpressionTraits<Expression>
    {};
 
    template<class Expression>
    constexpr bool isZero(Expression&&)
    {
      return ExpressionTraits<Expression>::isZero;
    }
 
    template<class UnOp, class LeftOperand, class RightOperand = void>
    struct ExpressionResult;
 
    template<class Operand>
    struct ExpressionResult<MinusOperation, Operand>
    {
      typedef decltype(-std::declval<Operand>()) Type;
      static auto apply(const Operand& arg) -> decltype(-arg)
      {
        return -arg;
      }
    };
 
    template<class Operand>
    struct ExpressionResult<PlusOperation, Operand>
    {
      typedef decltype(+std::declval<Operand>()) Type;
      static auto apply(const Operand& arg) -> decltype(+arg)
      {
        return +arg;
      }
    };
 
    template<class Operand>
    struct ExpressionResult<IdentityOperation, Operand>
    {
     private:
      typedef
      typename std::remove_reference<typename std::remove_const<Operand>::type>::type
      OperandType;
      enum {
        isExpression = std::is_base_of<ExpressionTemplate<OperandType>, OperandType>::value
      };
      template<class Object, bool expr>
      struct ResultHelper;
 
      template<class Object>
      struct ResultHelper<Object, true>
      {
        typedef decltype(*std::declval<Object>()) Type;
        static auto apply(const Object& arg) -> decltype(*arg)
        {
          return *arg;
        }
      };
 
      template<class Object>
      struct ResultHelper<Object, false>
      {
        typedef const Object& Type;
        static Type apply(Type arg)
        {
          return arg;
        }
      };
     public:
      typedef typename ResultHelper<OperandType, isExpression>::Type Type;
      static Type apply(const OperandType& arg)
      {
        return ResultHelper<OperandType, isExpression>::apply(arg);
      }
    };
 
    template<class Left, class Right>
    struct ExpressionResult<MinusOperation, Left, Right>
    {
      typedef decltype(std::declval<Left>()-std::declval<Right>()) Type;
      static auto apply(const Left& left, const Right& right) -> decltype(left-right)
      {
        return left-right;
      }
    };
 
    template<class Left, class Right>
    struct ExpressionResult<PlusOperation, Left, Right>
    {
      typedef decltype(std::declval<Left>()+std::declval<Right>()) Type;
      static auto apply(const Left& left, const Right& right) -> decltype(left+right)
      {
        return left+right;
      }
    };
 
    template<class Left, class Right>
    struct ExpressionResult<MultiplyOperation, Left, Right>
    {
      typedef decltype(std::declval<Left>()*std::declval<Right>()) Type;
      static auto apply(const Left& left, const Right& right) -> decltype(left*right)
      {
        return left*right;
      }
    };
 
    template<class Left, class Right>
    struct ExpressionResult<SMultiplyOperation, Left, Right>
    {
      typedef decltype(std::declval<Left>()*std::declval<Right>()) Type;
      static auto apply(const Left& left, const Right& right) -> decltype(left*right)
      {
        return left*right;
      }
    };
 
    template<class Op, class Left, class Right = void>
    static inline
    auto makeExpression(const Op, const Left& left, const Right& right)
      -> decltype(ExpressionResult<Op, Left, Right>::apply(left, right))
    {
      return ExpressionResult<Op, Left, Right>::apply(left, right);
    }
 
    template<class UnOp, class Value>
    struct UnaryExpressionTraits
    {
      typedef void ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return 111;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<MinusOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<IdentityOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<SquareOperation, Value>
    {
      typedef typename FieldTraits<Value>::field_type ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder*oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<CosOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<SinOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<TanOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<AtanOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<AcosOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<AsinOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class Value>
    struct UnaryExpressionTraits<SqrtOperation, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned oldOrder)
      {
        return oldOrder;
      }
    };
 
    template<class BinOp, class LeftValue, class RightValue>
    struct BinaryExpressionTraits
    {
      typedef void ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return 111;
      }
    };
 
    template<class Value>
    struct BinaryExpressionTraits<PlusOperation, Value, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return std::max(order1, order2);
      }
    };
 
    template<class Value>
    struct BinaryExpressionTraits<MinusOperation, Value, Value>
    {
      typedef Value ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return std::max(order1, order2);
      }
    };
 
    template<class Value>
    struct BinaryExpressionTraits<MultiplyOperation, Value, Value>
    {
      typedef typename FieldTraits<Value>::field_type ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
    template<class Field>
    struct BinaryExpressionTraits<SMultiplyOperation, Field, Field>
    {
      typedef FieldVector<Field, 1> ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
    template<class Field, int dimension>
    struct BinaryExpressionTraits<SMultiplyOperation, typename FieldTraits<Field>::field_type, FieldVector<Field, dimension> >
    {
      typedef FieldVector<Field, dimension> ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
    template<class Field, int dimension>
    struct BinaryExpressionTraits<SMultiplyOperation, FieldVector<Field, dimension>, typename FieldTraits<Field>::field_type>
    {
      typedef FieldVector<Field, dimension> ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
    template<class Field, int dimension>
    struct BinaryExpressionTraits<SMultiplyOperation, FieldVector<Field, 1>, FieldVector<Field, dimension> >
    {
      typedef FieldVector<Field, dimension> ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
    template<class Field, int dimension>
    struct BinaryExpressionTraits<SMultiplyOperation, FieldVector<Field, dimension>, FieldVector<Field, 1> >
    {
      typedef FieldVector<Field, dimension> ResultType;
      constexpr static unsigned polynomialOrder(unsigned order1, unsigned order2)
      {
        return order1 * order2;
      }
    };
 
 
 
  } // ACFem
 
} // Dune
 
#endif