GSLFunAdapters.cpp

Go to the documentation of this file.

// ============================================================================
// Include files
// ============================================================================
// GaudiGSL/GaudiMath
// ============================================================================
#include "GaudiMath/GSLFunAdapters.h"
#include "GaudiMath/GaudiMath.h"
// ============================================================================
// GSL
// ============================================================================
#include "gsl/gsl_mode.h"
#include "gsl/gsl_sf_result.h"
// ============================================================================

namespace Genfun
{
  namespace GaudiMathImplementation
  {

    GSLFunctionWithError::GSLFunctionWithError( GSLFunctionWithError::Function function )
        : AbsFunction(), m_function( function ), m_result( std::make_unique<gsl_sf_result>() )
    {
      m_result->val = -1.e+10;
      m_result->err = -1.e+10;
    }

    GSLFunctionWithError::GSLFunctionWithError( const GSLFunctionWithError& func )
        : AbsFunction(), m_function( func.m_function ), m_result( std::make_unique<gsl_sf_result>() )
    {
      m_result->val = func.m_result->val;
      m_result->err = func.m_result->err;
    }

    double GSLFunctionWithError::operator()( double x ) const
    {
      ( *m_function )( x, m_result.get() );
      return m_result->val;
    }

    double GSLFunctionWithError::operator()( const Genfun::Argument& x ) const
    {
      ( *m_function )( x[0], m_result.get() );
      return m_result->val;
    }

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

    GSLFunctionWithError::Function GSLFunctionWithError::function() const { return m_function; }

    const gsl_sf_result& GSLFunctionWithError::result() const { return *m_result; }

    double GSLFunctionWithError::error() const { return m_result->err; }

    GSLFunctionWithMode::GSLFunctionWithMode( GSLFunctionWithMode::Function function, const gsl_mode_t& mod )
        : AbsFunction(), m_function( function ), m_mode( std::make_unique<gsl_mode_t>( mod ) )
    {
    }

    GSLFunctionWithMode::GSLFunctionWithMode( const GSLFunctionWithMode& func )
        : AbsFunction(), m_function( func.m_function ), m_mode( std::make_unique<gsl_mode_t>( *( func.m_mode ) ) )
    {
    }

    double GSLFunctionWithMode::operator()( double x ) const { return ( *m_function )( x, *m_mode ); }

    double GSLFunctionWithMode::operator()( const Genfun::Argument& x ) const
    {
      return ( *m_function )( x[0], *m_mode );
    }

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

    GSLFunctionWithMode::Function GSLFunctionWithMode::function() const { return m_function; }

    const gsl_mode_t& GSLFunctionWithMode::mode() const { return *m_mode; }

    GSLFunctionWithModeAndError::GSLFunctionWithModeAndError( GSLFunctionWithModeAndError::Function function,
                                                              const gsl_mode_t&                     mod )
        : AbsFunction()
        , m_function( function )
        , m_mode( std::make_unique<gsl_mode_t>( mod ) )
        , m_result( std::make_unique<gsl_sf_result>( gsl_sf_result{-1.e+10, -1.e+10} ) )
    {
    }

    GSLFunctionWithModeAndError::GSLFunctionWithModeAndError( const GSLFunctionWithModeAndError& func )
        : AbsFunction()
        , m_function( func.m_function )
        , m_mode( std::make_unique<gsl_mode_t>( *func.m_mode ) )
        , m_result( std::make_unique<gsl_sf_result>( *func.m_result ) )
    {
    }

    double GSLFunctionWithModeAndError::operator()( double x ) const
    {
      ( *m_function )( x, *m_mode, m_result.get() );
      return m_result->val;
    }

    double GSLFunctionWithModeAndError::operator()( const Genfun::Argument& x ) const
    {
      ( *m_function )( x[0], *m_mode, m_result.get() );
      return m_result->val;
    }

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

    GSLFunctionWithModeAndError::Function GSLFunctionWithModeAndError::function() const { return m_function; }

    const gsl_mode_t& GSLFunctionWithModeAndError::mode() const { return *m_mode; }

    const gsl_sf_result& GSLFunctionWithModeAndError::result() const { return *m_result; }

    double GSLFunctionWithModeAndError::error() const { return m_result->err; }

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