Derivative.hpp

#pragma once

#include <type_traits>

#include <amdis/common/Concepts.hpp>
#include <amdis/common/DerivativeTraits.hpp>
#include <amdis/common/Index.hpp>

namespace AMDiS
{
  template <class LocalFunction, class Type,
    REQUIRES(std::is_convertible_v<tag::derivative_type, Type>)>
  auto derivativeOf(LocalFunction const& lf, Type const& type)
    -> decltype(lf.makeDerivative(type))
  {
    return lf.makeDerivative(type);
  }

  namespace Concepts
  {
    namespace Definition
    {
      struct HasDerivative
      {
        template <class F, class T>
        auto require(F&& f, T&& t) -> decltype( derivativeOf(f,t) );
      };

      struct HasLocalFunctionDerivative
      {
        template <class F, class T>
        auto require(F&& f, T&& t) -> decltype( derivativeOf(localFunction(f),t) );
      };

      struct HasPartial
      {
        template <class F, class I>
        auto require(F&& f, I&& i) -> decltype( partial(f, i) );
      };

    } // end namespace Definition


    template <class GF, class Type>
    constexpr bool HasDerivative = models<Definition::HasDerivative(GF,Type)>;

    template <class GF, class Type>
    using HasDerivative_t = models_t<Definition::HasDerivative(GF,Type)>;


    template <class GF, class Type>
    constexpr bool HasLocalFunctionDerivative = models<Definition::HasLocalFunctionDerivative(GF,Type)>;

    template <class GF, class Type>
    using HasLocalFunctionDerivative_t = models_t<Definition::HasLocalFunctionDerivative(GF,Type)>;


    template <class F>
    constexpr bool HasPartial = models<Definition::HasPartial(F,index_t<0>)>;

    template <class F>
    using HasPartial_t = models_t<Definition::HasPartial(F,index_t<0>)>;

  } // end namespace Concepts

} // end namespace AMDiS