static_wrapper.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/analytic/function.hpp>
 
namespace FEAT
{
  namespace Analytic
  {
    template<typename DataType_>
    class StaticFunction
    {
    public:
#ifdef DOXYGEN
      static DataType_ eval(DataType_ x);
 
      static DataType_ eval(DataType_ x, DataType_ y);
 
      static DataType_ eval(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_x(DataType_ x);
 
      static DataType_ der_x(DataType_ x, DataType_ y);
 
      static DataType_ der_x(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_y(DataType_ x);
 
      static DataType_ der_y(DataType_ x, DataType_ y);
 
      static DataType_ der_y(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_z(DataType_ x);
 
      static DataType_ der_z(DataType_ x, DataType_ y);
 
      static DataType_ der_z(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_xx(DataType_ x);
 
      static DataType_ der_xx(DataType_ x, DataType_ y);
 
      static DataType_ der_xx(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_yy(DataType_ x);
 
      static DataType_ der_yy(DataType_ x, DataType_ y);
 
      static DataType_ der_yy(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_zz(DataType_ x);
 
      static DataType_ der_zz(DataType_ x, DataType_ y);
 
      static DataType_ der_zz(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_xy(DataType_ x, DataType_ y);
 
      static DataType_ der_xy(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_yx(DataType_ x, DataType_ y);
 
      static DataType_ der_yx(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_xz(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_zx(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_yz(DataType_ x, DataType_ y, DataType_ z);
 
      static DataType_ der_zy(DataType_ x, DataType_ y, DataType_ z);
#endif // DOXYGEN
    }; // class StaticFunction
 
    namespace Intern
    {
      template<
        template<typename> class Function_,
        typename DataType_,
        int dim_,
        bool enable_>
      struct StaticFunctionWrapper;
 
      // specialization for 1D functions
      template<template<typename> class Function_, typename DataType_>
      struct StaticFunctionWrapper<Function_, DataType_, 1, true>
      {
        template<typename Value_, typename Point_>
        static void eval(Value_& v, const Point_& x)
        {
          v = Function_<DataType_>::eval(x[0]);
        }
 
        template<typename Value_, typename Point_>
        static void grad(Value_& v, const Point_& x)
        {
          v[0] = Function_<DataType_>::der_x(x[0]);
        }
 
        template<typename Value_, typename Point_>
        static void hess(Value_& v, const Point_& x)
        {
          v[0][0] = Function_<DataType_>::der_xx(x[0]);
        }
      };
 
      // specialization for 2D functions
      template<template<typename> class Function_, typename DataType_>
      struct StaticFunctionWrapper<Function_, DataType_, 2, true>
      {
        template<typename Value_, typename Point_>
        static void eval(Value_& v, const Point_& x)
        {
          v = Function_<DataType_>::eval(x[0], x[1]);
        }
 
        template<typename Value_, typename Point_>
        static void grad(Value_& v, const Point_& x)
        {
          v[0] = Function_<DataType_>::der_x(x[0], x[1]);
          v[1] = Function_<DataType_>::der_y(x[0], x[1]);
        }
 
        template<typename Value_, typename Point_>
        static void hess(Value_& v, const Point_& x)
        {
          v[0][0] = Function_<DataType_>::der_xx(x[0], x[1]);
          v[0][1] = Function_<DataType_>::der_xy(x[0], x[1]);
          v[1][0] = Function_<DataType_>::der_yx(x[0], x[1]);
          v[1][1] = Function_<DataType_>::der_yy(x[0], x[1]);
        }
      };
 
      // specialization for 3D functions
      template<template<typename> class Function_, typename DataType_>
      struct StaticFunctionWrapper<Function_, DataType_, 3, true>
      {
        template<typename Value_, typename Point_>
        static void eval(Value_& v, const Point_& x)
        {
          v = Function_<DataType_>::eval(x[0], x[1],x[2]);
        }
 
        template<typename Value_, typename Point_>
        static void grad(Value_& v, const Point_& x)
        {
          v[0] = Function_<DataType_>::der_x(x[0], x[1], x[2]);
          v[1] = Function_<DataType_>::der_y(x[0], x[1], x[2]);
          v[2] = Function_<DataType_>::der_z(x[0], x[1], x[2]);
        }
 
        template<typename Value_, typename Point_>
        static void hess(Value_& v, const Point_& x)
        {
          v[0][0] = Function_<DataType_>::der_xx(x[0], x[1], x[2]);
          v[0][1] = Function_<DataType_>::der_xy(x[0], x[1], x[2]);
          v[0][2] = Function_<DataType_>::der_xz(x[0], x[1], x[2]);
          v[1][0] = Function_<DataType_>::der_yx(x[0], x[1], x[2]);
          v[1][1] = Function_<DataType_>::der_yy(x[0], x[1], x[2]);
          v[1][2] = Function_<DataType_>::der_yz(x[0], x[1], x[2]);
          v[2][0] = Function_<DataType_>::der_zx(x[0], x[1], x[2]);
          v[2][1] = Function_<DataType_>::der_zy(x[0], x[1], x[2]);
          v[2][2] = Function_<DataType_>::der_zz(x[0], x[1], x[2]);
        }
      };
    } // namespace Intern
 
    template<
      int domain_dim_,
      template<typename> class Function_,
      bool can_value_ = true,
      bool can_grad_ = false,
      bool can_hess_ = false>
    class StaticWrapperFunction :
      public Analytic::Function
    {
    public:
      static_assert((1 <= domain_dim_) && (domain_dim_ <= 3), "invalid domain dimension");
 
      static constexpr int domain_dim = domain_dim_;
 
      typedef Analytic::Image::Scalar ImageType;
 
      static constexpr bool can_value = can_value_;
      static constexpr bool can_grad = can_grad_;
      static constexpr bool can_hess = can_hess_;
 
      StaticWrapperFunction() {}
      StaticWrapperFunction(const StaticWrapperFunction&) {}
      StaticWrapperFunction(StaticWrapperFunction&&) {}
 
      template<typename Traits_>
      class Evaluator :
        public Analytic::Function::Evaluator<Traits_>
      {
      public:
        typedef typename Traits_::DataType DataType;
        typedef typename Traits_::PointType PointType;
        typedef typename Traits_::ValueType ValueType;
        typedef typename Traits_::GradientType GradientType;
        typedef typename Traits_::HessianType HessianType;
 
      public:
        explicit Evaluator(const StaticWrapperFunction&)
        {
        }
 
        ValueType value(const PointType& point) const
        {
          ValueType val;
          Intern::StaticFunctionWrapper<Function_, DataType, domain_dim, can_value_>::eval(val, point);
          return val;
        }
 
        GradientType gradient(const PointType& point) const
        {
          GradientType grad;
          Intern::StaticFunctionWrapper<Function_, DataType, domain_dim, can_grad_>::grad(grad, point);
          return grad;
        }
 
        HessianType hessian(const PointType& point) const
        {
          HessianType hess;
          Intern::StaticFunctionWrapper<Function_, DataType, domain_dim, can_hess_>::hess(hess, point);
          return hess;
        }
      }; // class StaticWrapperFunction::Evaluator<...>
    }; // class StaticWrapperFunction
  } // namespace Analytic
} // namespace FEAT