FunAdapters.h

Go to the documentation of this file.

#ifndef GAUDIMATH_FUNADAPTERS_H
#define GAUDIMATH_FUNADAPTERS_H 1
// ============================================================================
// Include files
// ============================================================================
#include <boost/variant.hpp>
#include <memory>
// ============================================================================
// from CLHEP
// ============================================================================
#include "CLHEP/GenericFunctions/AbsFunction.hh"
#include "CLHEP/GenericFunctions/Argument.hh"
#include "CLHEP/GenericFunctions/GenericFunctions.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
// ============================================================================