CepsFunction.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
#include <functional>
 
#include "common/core/CepsTypes.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/core/CepsEnums.hpp"
#include "common/core/CepsTypeTools.hpp"
#include "common/core/CepsMathOperations.hpp"
#include "common/core/CepsMemory.hpp"
 
namespace ceps
{
 
  template <typename _Signature>
  struct Function;
 
  template <class _Fn>
  struct ResultOfImpl
  {
    using type = _Fn;
  };
 
  template <typename _Res, typename... _Args>
  struct ResultOfImpl<Function<_Res(_Args...)>>
  {
    using type = _Res;
  };
 
  template <template <class> class _DerivedFn, class _Signature>
  requires std::derived_from<_DerivedFn<_Signature>, Function<_Signature>>
  struct ResultOfImpl<_DerivedFn<_Signature>>
  {
    using type = typename ResultOfImpl<Function<_Signature>>::type;
  };
 
  template <class _Fn>
  using ResultOf = typename ResultOfImpl<_Fn>::type;
 
  template <typename _Res, typename... _Args>
  struct Function<_Res(_Args...)>
  {
 
    using ReturnType = _Res;
   
    using SignatureType = _Res(_Args...);
   
    Function() = default;
   
    Function(const Function&) = default;
   
    Function(Function&&) noexcept = default;
   
    Function&
    operator= (const Function&) = default;
   
    Function&
    operator=(Function&&) noexcept = default;
   
    virtual ~Function() = default;
   
    _Res
    virtual eval(_Args... args) = 0;
   
    _Res
    virtual operator() (_Args... args) final
    {
      return this->eval(std::forward<_Args>(args)...);
    }
 
  };
 
  // ==========================================================================================
 
  template <class _Class, class _MemberPtr>
  struct MemberFunction;
 
  template <class _Res, class _Class, class... _Args>
  struct MemberFunction<_Class, _Res(_Class::*)(_Args...)> : public Function<_Res(_Args...)>
  {
 
    _Class* m_obj; 
    _Res(_Class::*m_pmf)(_Args...); 
   
    MemberFunction(_Class& obj, _Res(_Class::*pmf)(_Args...)) :
      m_obj (&obj),
      m_pmf (pmf)
    {}
   
    MemberFunction(const MemberFunction &that) :
      m_obj (that.m_obj),
      m_pmf (that.m_pmf)
    {}
   
    ~MemberFunction() override
    {}
   
    _Res
    eval(_Args... args) final
    {
      return ((*m_obj).*m_pmf)(std::forward<_Args> (args)...);
    }
  };
 
  template <typename _Res, typename _Class, typename... _Args>
  struct MemberFunction<_Class*, _Res(_Class::*)(_Args...)> : public Function<_Res(_Args...)>
  {
 
    _Class* m_obj;                  
    _Res(_Class::*m_pmf)(_Args...); 
 
    MemberFunction(_Class *obj, _Res(_Class::*pmf)(_Args...)) :
      m_obj(obj),
      m_pmf(pmf)
    {}
 
    MemberFunction(const MemberFunction &that) :
      m_obj(that.m_obj),
      m_pmf(that.m_pmf)
    {}
 
    ~MemberFunction() override
    {}
 
    _Res
    eval(_Args... args) final
    {
      return ((*m_obj).*m_pmf)(std::forward<_Args>(args)...);
    }
  };
 
  template <class _Class, class _Res, class... _Args>
  inline auto
  asFunction(_Class obj,_Res(_Class::*fn)(_Args...)) noexcept
  {
    return MemberFunction<_Class,_Res(_Class::*)(_Args...)>(obj,fn);
  }
 
  template <class _Class, class _Res, class... _Args>
  inline auto
  asFunction(_Class *obj,_Res(_Class::*fn)(_Args...)) noexcept
  {
    return MemberFunction<_Class*,_Res(_Class::*)(_Args...)>(obj,fn);
  }
 
  template <class _Class, class _Res, class... _Args>
  inline auto
  newFunction(_Class obj,_Res(_Class::*fn)(_Args...)) noexcept
  {
    return ceps::getNew<MemberFunction<_Class,_Res(_Class::*)(_Args...)>> (obj,fn);
  }
 
  template <class _Class, class _Res, class... _Args>
  inline auto
  newFunction(_Class* obj,_Res(_Class::*fn)(_Args...)) noexcept
  {
    return ceps::getNew<MemberFunction<_Class*,_Res(_Class::*)(_Args...)>>(obj,fn);
  }
 
  // ==========================================================================================
  
  template <class _Signature>
  struct ConstantFunction;
 
  template <class _Res, class... _Args>
  struct ConstantFunction<_Res(_Args...)> : public Function<_Res(_Args...)>
  {
 
    const _Res& m_var; 
    
    explicit ConstantFunction(const _Res& var) :
      m_var(var)
    {}
    
    ConstantFunction(const ConstantFunction& that) :
      m_var(that.m_var)
    {}
    
    ~ConstantFunction() override
    {}
    
    _Res
    eval(_Args... /*args*/) override
    {
      return m_var;
    }
  };
 
  template <class _Res, class... _Args>
  inline ConstantFunction<_Res(_Args...)>
  asFunction (const _Res &arg) noexcept
  {
    return ConstantFunction<_Res(_Args...)>(arg);
  }
 
  template <CepsSize _N, class _Object, class _Signature>
  struct PiecewiseFunction;
 
  template <CepsSize _N, class _Object, class _Res, class... _Args>
  struct PiecewiseFunction<_N, _Object, _Res(_Args...)> : public Function<_Res(_Args...)>
  {
    public:
      using KeyType = std::remove_cvref_t<std::tuple_element_t<_N, CepsTuple<_Args...>>>;
      CepsMap<KeyType, _Object> m_map;
   
      explicit PiecewiseFunction(const CepsMap<KeyType, _Object>& map) :
          m_map(map)
      {}
   
      PiecewiseFunction(const PiecewiseFunction& that) :
          m_map(that.m_map)
      {}
   
      ~PiecewiseFunction() override
      {}
   
      _Res
      eval(_Args... args) final
      {
        KeyType key = std::get<_N> (std::forward_as_tuple<_Args...>(args...));
        CEPS_ABORT_IF (not m_map.contains(key), "no key : " << key);
        return std::invoke(&m_map.at(key), args...);
      }
  };
 
  template<char _Op, typename _T1, typename _T2>
  struct ResultOfOperationStruct;
 
  template<typename _T1, typename _T2>
  struct ResultOfOperationStruct<'+', _T1, _T2> 
  {
    using type = decltype(CepsMathOperation<_T1, _T2>::plus(std::declval<_T1>(),std::declval<_T2>()));
  };
 
  template<typename _T1, typename _T2>
  struct ResultOfOperationStruct<'-', _T1, _T2> 
  {
    using type = decltype(CepsMathOperation<_T1, _T2>::minus(std::declval<_T1>(),std::declval<_T2>()));
  };
 
  template<typename _T1, typename _T2>
  struct ResultOfOperationStruct<'*', _T1, _T2> 
  {
    using type = decltype(CepsMathOperation<_T1, _T2>::mult(std::declval<_T1>(),std::declval<_T2>()));
  };
 
  template<typename _T1, typename _T2>
  struct ResultOfOperationStruct<'/', _T1, _T2> 
  {
    using type = decltype(CepsMathOperation<_T1, _T2>::div(std::declval<_T1>(),std::declval<_T2>()));
  };
 
  template<char _Op, typename _T1, typename _T2>
  using ResultOfOperation = typename ResultOfOperationStruct<_Op, _T1, _T2>::type;
 
  template <char _Op, typename _Res1, typename _Res2, typename... _Args>
  struct FunctionOperation:
    public Function<ResultOfOperation<_Op, _Res1, _Res2>(_Args...)>
  {
    using Fn1    = Function<_Res1 (_Args...)>;
    using Fn2    = Function<_Res2 (_Args...)>;
    using Result = ResultOfOperation<_Op, _Res1, _Res2>;
 
    const Fn1* m_fn1; ///< @brief left operand
    const Fn2* m_fn2; ///< @brief right operand
 
    FunctionOperation(const Fn1* fn1, const Fn2* fn2) :
        m_fn1 (fn1),
        m_fn2 (fn2)
    {}
 
    FunctionOperation(const FunctionOperation& fp) = default;
 
    FunctionOperation&
    operator=(const FunctionOperation& fp) = default;
 
    Result
    eval(_Args... args) override
    {
      _Res1 res1 = this->m_fn1->operator()(std::forward<_Args> (args)...);
      _Res2 res2 = this->m_fn2->operator()(std::forward<_Args> (args)...);
 
      if constexpr (_Op == '+')
        return CepsMathOperation<_Res1, _Res2>::plus(res1, res2);
      if constexpr (_Op == '-')
        return CepsMathOperation<_Res1, _Res2>::minus(res1, res2);
      if constexpr (_Op == '*')
        return CepsMathOperation<_Res1, _Res2>::mult(res1, res2);
      if constexpr (_Op == '/')
        return CepsMathOperation<_Res1, _Res2>::div(res1, res2);
    }
  };
 
} // namespace ceps
 
template<typename _T1, typename _T2, typename... _Args>
ceps::FunctionOperation<'+', _T1, _T2, _Args...>
operator+(const ceps::Function<_T1(_Args...)>& f1, const ceps::Function<_T2(_Args...)>& f2)
{
  return {&f1,&f2};
}
 
template<typename _T1, typename _T2, typename... _Args>
ceps::FunctionOperation<'-', _T1, _T2, _Args...>
operator-(const ceps::Function<_T1(_Args...)>& f1, const ceps::Function<_T2(_Args...)>& f2)
{
  return {&f1,&f2};
}
 
template<typename _T1, typename _T2, typename... _Args>
ceps::FunctionOperation<'*', _T1, _T2, _Args...>
operator*(const ceps::Function<_T1(_Args...)>& f1, const ceps::Function<_T2(_Args...)>& f2)
{
  return {&f1,&f2};
}
 
template<typename _T1, typename _T2, typename... _Args>
ceps::FunctionOperation<'/', _T1, _T2, _Args...>
operator/(const ceps::Function<_T1(_Args...)>& f1, const ceps::Function<_T2(_Args...)>& f2)
{
  return {&f1,&f2};
}