FunAdapters.h

Go to the documentation of this file.

#ifndef GAUDIMATH_FUNADAPTERS_H
#define GAUDIMATH_FUNADAPTERS_H 1
// ============================================================================
// Include files
// ============================================================================
#include <memory>
#include <boost/variant.hpp>
// ============================================================================
// from CLHEP
// ============================================================================
#include "CLHEP/GenericFunctions/GenericFunctions.hh"
#include "CLHEP/GenericFunctions/Argument.hh"
#include "CLHEP/GenericFunctions/AbsFunction.hh"
// ============================================================================
#include "GaudiKernel/Kernel.h"

#if defined(__clang__) || defined(__CLING__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#elif defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsuggest-override"
#endif


namespace detail {
#if  __cplusplus > 201402L

// C++17 version: https://godbolt.org/g/2vAZQt
template <typename... lambda_ts>
struct composer_t : lambda_ts...
{
  template <typename... T>
  composer_t(T&&... t) : lambda_ts(std::forward<T>(t))...  {}

  using lambda_ts::operator()...;
};

#else

template <typename... lambda_ts>
struct composer_t;

template <typename lambda_t>
struct composer_t<lambda_t> : lambda_t {
  composer_t(const lambda_t& lambda): lambda_t{lambda} { }
  composer_t(lambda_t&& lambda): lambda_t{std::move(lambda)} { }

  using lambda_t::operator();
};

template <typename lambda_t, typename... more_lambda_ts>
struct composer_t<lambda_t, more_lambda_ts...> : lambda_t, composer_t<more_lambda_ts...> {
  using super_t = composer_t<more_lambda_ts...>;
  template <typename... lambda_ts>
  composer_t(const lambda_t& lambda, lambda_ts&&... more_lambdas): lambda_t{lambda}, super_t{std::forward<lambda_ts>(more_lambdas)...} { }
  template <typename... lambda_ts>
  composer_t(lambda_t&& lambda, lambda_ts&&... more_lambdas): lambda_t{std::move(lambda)}, super_t{std::forward<lambda_ts>(more_lambdas)...} { }
  using lambda_t::operator();
  using super_t::operator();
};
#endif

template <typename... lambda_ts>
composer_t<std::decay_t<lambda_ts>...>
compose(lambda_ts&&... lambdas)
{ return {std::forward<lambda_ts>(lambdas)...}; }


auto dispatch_variant = [](auto&& variant, auto&&... lambdas) -> decltype(auto) {
  return boost::apply_visitor( compose( std::forward<decltype(lambdas)>(lambdas)... ),
                               std::forward<decltype(variant)>(variant) );
};

}

namespace AIDA { class IFunction ; }

namespace Genfun
{
  namespace GaudiMathImplementation
  {
    // ========================================================================
    // =========================================================================

    class GAUDI_API AdapterIFunction : public AbsFunction
    {
    public:
      FUNCTION_OBJECT_DEF( AdapterIFunction )
    public:
      AdapterIFunction ( const AIDA::IFunction& fun) ;
      AdapterIFunction ( const AdapterIFunction& ) = default;

      double operator() ( double a          ) const override;

      double operator() ( const Argument& x ) const override;

      unsigned int dimensionality () const override { return m_arg.size() ; }

      bool  hasAnalyticDerivative() const override { return true ; }
      Genfun::Derivative partial( unsigned int i  ) const override;

      AdapterIFunction& operator=(const AdapterIFunction&) = delete;
    private:
      const AIDA::IFunction*      m_fun ;
      mutable std::vector<double> m_arg ;
    };
    FUNCTION_OBJECT_IMP( AdapterIFunction )

    // ========================================================================
    // ========================================================================
    class GAUDI_API Adapter2DoubleFunction : public AbsFunction
    {
    public:
      typedef double (*Function)( const double ,
                                  const double ) ;
    public:
      FUNCTION_OBJECT_DEF( Adapter2DoubleFunction )
    public:
      Adapter2DoubleFunction ( Function func );
      Adapter2DoubleFunction ( const Adapter2DoubleFunction& ) = default;

      double operator() (       double    x ) const override;

      double operator() ( const Argument& x ) const override;

      unsigned int dimensionality() const override { return 2    ; }
      bool  hasAnalyticDerivative() const override { return true ; }
      Genfun::Derivative partial( unsigned int i  ) const override;
    public:
      double operator() ( const double x , const double y ) const ;

      // assigmenet operator is disabled
      Adapter2DoubleFunction& operator = ( const Adapter2DoubleFunction&) = delete;
    private:
      Function                 m_func = nullptr ;
    };
    FUNCTION_OBJECT_IMP( Adapter2DoubleFunction )

    // ========================================================================
    // ========================================================================
    class GAUDI_API Adapter3DoubleFunction : public AbsFunction
    {
    public:
      typedef double (*Function)( const double ,
                                  const double ,
                                  const double ) ;
    public:
      FUNCTION_OBJECT_DEF( Adapter3DoubleFunction )
    public:
      Adapter3DoubleFunction ( Function func );
      Adapter3DoubleFunction ( const Adapter3DoubleFunction& ) = default;

      double operator() (       double    x ) const override ;

      double operator() ( const Argument& x ) const override ;

      unsigned int dimensionality() const override { return 3    ; }
      bool  hasAnalyticDerivative() const override { return true ; }
      Genfun::Derivative partial( unsigned int i  ) const override ;
    public:
      double operator() ( const double x ,
                          const double y ,
                          const double z ) const ;
    private:
      // assignment operator is disabled
      Adapter3DoubleFunction& operator = ( const Adapter3DoubleFunction&);
    private:
      Function                 m_func = nullptr ;
    };
    FUNCTION_OBJECT_IMP( Adapter3DoubleFunction )

    // ========================================================================
    // ========================================================================
    class GAUDI_API SimpleFunction : public AbsFunction
    {
    public:
      typedef double (*Function1)( const double               ) ;
      typedef double (*Function2)( const double*              ) ;
      typedef double (*Function3)( const std::vector<double>& ) ;
    public:
      FUNCTION_OBJECT_DEF( SimpleFunction )

    public:

      SimpleFunction ( Function1 func ) ;

      SimpleFunction ( Function2    func ,
                       const size_t dim ) ;

      SimpleFunction ( Function3    func ,
                       const size_t dim ) ;

    public:

      unsigned int dimensionality         () const override {
        return detail::dispatch_variant( m_func,
               [](Function1) { return 1ul; },
               [&](auto) { return m_arg.size(); } );
      }
      bool  hasAnalyticDerivative         () const override { return true    ; }
      double             operator()  ( double          ) const override ;
      double             operator()  ( const Argument& ) const override ;
      Genfun::Derivative partial     ( unsigned int i  ) const override ;

    private:

      boost::variant<Function1,Function2,Function3> m_func;
      mutable std::vector<double>  m_arg     ;
    };
    FUNCTION_OBJECT_IMP( SimpleFunction )

  } // end of namespace GaudiMathImeplementation
} // end of namespace Genfun

#if defined(__clang__) || defined(__CLING__)
#pragma clang diagnostic pop
#elif defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic pop
#endif

#endif // GAUDIMATH_FUNADAPTERS_H
// ============================================================================