Adapter.cpp

Go to the documentation of this file.

// Include files
// ============================================================================
// GaudiMath
// ============================================================================
#include "GaudiMath/GaudiMath.h"
// ============================================================================
// AIDA
// ============================================================================
#include "AIDA/IFunction.h"
// ============================================================================
#include <cstring>
#include <cassert>


namespace Genfun
{
  namespace GaudiMathImplementation
  {

    AdapterIFunction::AdapterIFunction ( const AIDA::IFunction& fun)
      : m_fun ( &fun  )
      , m_arg ( fun.dimension() , 0 )
    {}

    double AdapterIFunction::operator() ( double x ) const
    {
      assert(begin(m_arg)!=end(m_arg));
      m_arg[0] = x ;
      std::fill( std::next(begin(m_arg)), end(m_arg), 0.0 );
      return m_fun -> value ( m_arg ) ;
    }

    double AdapterIFunction::operator() ( const Genfun::Argument& x ) const
    {
      for ( size_t i = 0; i < m_arg.size(); ++i ) { m_arg[i] = x[i] ; }
      return m_fun -> value ( m_arg ) ;
    }

    Genfun::Derivative AdapterIFunction::partial( unsigned int i  ) const
    {
      if ( i >= m_arg.size() ) {
        const AbsFunction& aux = GaudiMath::Constant( 0 , m_arg.size()  ) ;
        return Genfun::FunctionNoop( &aux ) ;
      };
      const AbsFunction& aux = GaudiMath::Derivative( *this , i ) ;
      return Genfun::FunctionNoop ( &aux ) ;
    }

    Adapter2DoubleFunction::Adapter2DoubleFunction
    ( Adapter2DoubleFunction::Function  func )
      : AbsFunction()
      , m_func      ( func  )
    {}


    double Adapter2DoubleFunction::operator()( double x ) const
    { return m_func ( x , 0 ) ; }

    double Adapter2DoubleFunction::operator()( const Genfun::Argument& x ) const
    { return m_func ( x[0] , x[1] ) ; }

    double Adapter2DoubleFunction::operator()( const double x ,
                                               const double y ) const
    { return m_func ( x , y ) ; }

    Genfun::Derivative Adapter2DoubleFunction::partial( unsigned int i  ) const
    {
      if ( i>=2 ) {
        GaudiMath::Constant aux{ 0 , 2 };
        return Genfun::FunctionNoop( &aux ) ;
      }
      GaudiMath::Derivative aux{ *this , i };
      return Genfun::FunctionNoop( &aux ) ;

    }

    Adapter3DoubleFunction::Adapter3DoubleFunction
    ( Adapter3DoubleFunction::Function  func )
    : m_func      ( func  )
    {}

    double Adapter3DoubleFunction::operator()( double x ) const
    { return m_func ( x , 0 , 0 ) ; }

    double Adapter3DoubleFunction::operator()( const Genfun::Argument& x ) const
    { return m_func ( x[0] , x[1] , x[2] ) ; }

    double Adapter3DoubleFunction::operator()( const double x ,
                                               const double y ,
                                               const double z ) const
    { return m_func ( x , y , z ) ; }

    Genfun::Derivative Adapter3DoubleFunction::partial( unsigned int i  ) const
    {
      if ( i>=3 ) {
        GaudiMath::Constant aux{ 0 , 3 };
        return Genfun::FunctionNoop ( &aux ) ;
      }
      GaudiMath::Derivative aux{ *this , i };
      return Genfun::FunctionNoop ( &aux ) ;
    }

    // ========================================================================

    // =======================================================================
    // ========================================================================
    SimpleFunction::SimpleFunction
    ( SimpleFunction::Function1 func )
    : m_func( func )
    {}
    // ========================================================================

    // ========================================================================
    // ========================================================================
    SimpleFunction::SimpleFunction
    ( SimpleFunction::Function2 func ,
      const size_t              dim  )
    : m_func     ( func )
    , m_arg      ( dim, 0 )
    {}
    // ========================================================================

    // ========================================================================
    // ========================================================================
    SimpleFunction::SimpleFunction
    ( SimpleFunction::Function3 func ,
      const size_t              dim  )
    : m_func     ( func )
    , m_arg      ( dim  , 0 )
    {}
    // ========================================================================

    // ========================================================================
    // ========================================================================
    Genfun::Derivative SimpleFunction::partial( unsigned int i ) const
    {
      const auto dim = dimensionality();
      if ( i>= dim ) {
         GaudiMath::Constant aux{ 0 , dim };
         return Genfun::FunctionNoop( &aux ) ;
      }
      GaudiMath::Derivative aux{ *this , i };
      return Genfun::FunctionNoop( &aux ) ;
    }

    // ========================================================================
    // ========================================================================
    double SimpleFunction::operator()  ( double value ) const
    {
      return detail::dispatch_variant( m_func,
            [&](const Function1& fun) { return (*fun)(value); },
            [&](const Function2& fun) { m_arg[0] = value  ;
                                        std::fill( std::next(m_arg.begin()) , m_arg.end() , 0.0 );
                                        return (*fun) ( m_arg.data() ) ; },
            [&](const Function3& fun) { m_arg[0] = value  ;
                                        std::fill ( std::next(m_arg.begin()) , m_arg.end() , 0.0 );
                                        return (*fun) ( m_arg ) ; } );
    }
    // ========================================================================

    // ========================================================================
    // ========================================================================
    double SimpleFunction::operator()  ( const Argument& argument ) const
    {
      return detail::dispatch_variant( m_func,
            [&](const Function1& f) { return (*f)(argument[0]); },
            [&](const Function2& f) { for ( size_t i = 0; i < m_arg.size(); ++i ) { m_arg[i] = argument[i] ; }
                                      return (*f)( m_arg.data() ) ; },
            [&](const Function3& f) { for ( size_t i = 0; i < m_arg.size(); ++i ) { m_arg[i] = argument[i] ; }
                                      return (*f)( m_arg ); } );
    }

  } // end of namespace GaudiMathImplementation
} // end of namespace Genfun


// ============================================================================
// The END
// ============================================================================