parameteroperations.hh

#ifndef __DUNE_ACFEM_PARAMETER_OPERATIONS__
#define __DUNE_ACFEM_PARAMETER_OPERATIONS__
 
#include "../expressions/expressionoperations.hh"
#include "../expressions/parameterinterface.hh"
 
namespace Dune {
 
  namespace ACFem {
 
    template<class UnOp>
    struct UnaryParameterOperation;
 
    template<class BinOp>
    struct BinaryParameterOperation;
 
    template<>
    struct UnaryParameterOperation<MinusOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        result = -value;
      }
    };
 
    template<>
    struct UnaryParameterOperation<SinOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::sin(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<CosOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::cos(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<TanOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::tan(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<AtanOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::atan(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<AsinOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::asin(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<AcosOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::acos(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<SqrtOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::sqrt(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<ExpOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = std::exp(value[k]);
        }
      }
    };
 
    template<>
    struct UnaryParameterOperation<SquareOperation>
    {
      template<class Value>
      static void evaluate(const Value& value, Value& result)
      {
        for (int k = 0; k < Value::dimension; ++k) {
          result[k] = value[k] * value[k];
        }
      }
    };
 
    template<>
    struct BinaryParameterOperation<PlusOperation>
    {
      template<class LeftValue, class RightValue, class Value>
      static void evaluate(const LeftValue& left, const RightValue& right, Value& result)
      {
        result = left + right;
      }
    };
 
    template<>
    struct BinaryParameterOperation<MinusOperation>
    {
      template<class LeftValue, class RightValue, class Value>
      static void evaluate(const LeftValue& left, const RightValue& right, Value& result)
      {
        result = left - right;
      }
    };
 
    template<>
    struct BinaryParameterOperation<MultiplyOperation>
    {
      template<class LeftValue, class RightValue, class Value>
      static void evaluate(const LeftValue& left, const RightValue& right, Value& result)
      {
        result = left * right;
      }
    };
 
    template<>
    struct BinaryParameterOperation<SMultiplyOperation>
    {
      template<class LeftValue, class RightValue, class Value>
      static void evaluate(const LeftValue& left, const RightValue& right, Value& result)
      {
        result = left * right;
      }
    };
 
 
 
  } // ACFem::
 
} // Dune::
 
#endif