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"
#include "GaudiKernel/compose.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 {

  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 )

  } // namespace GaudiMathImplementation
} // 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