NumericalDerivative.cpp

Go to the documentation of this file.

// ============================================================================
// Include files
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/GaudiException.h"
// ============================================================================
// local
// ============================================================================
#include "GaudiMath/NumericalDerivative.h"
#include "GaudiMath/Constant.h"
// ============================================================================
// GSL 
// ============================================================================
#include "gsl/gsl_errno.h"
#include "gsl/gsl_diff.h"
#include "gsl/gsl_math.h"
// ============================================================================
// local
// ============================================================================
#include "Helpers.h"
// ============================================================================

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

namespace Genfun
{
  namespace GaudiMathImplementation
  {
    // ========================================================================
    // ========================================================================
    FUNCTION_OBJECT_IMP( NumericalDerivative )
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    NumericalDerivative::NumericalDerivative
    ( const AbsFunction&               function , 
      const size_t                     index    , 
      const NumericalDerivative::Type& type     )
      : AbsFunction () 
      , m_function  ( function.clone()          )  
      , m_index     ( index                     ) 
      , m_DIM       ( function.dimensionality() )
      , m_type      ( type                      )
      , m_argument  ( function.dimensionality() )
      , m_result    ( GSL_NEGINF                )
      , m_error     ( GSL_POSINF                )
    {
      if( m_index >= m_DIM ) 
        { Exception ( "::constructor invalid variable index " ) ; };
    }
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    NumericalDerivative::NumericalDerivative 
    ( const NumericalDerivative&   right    ) 
      : AbsFunction () 
      , m_function  ( right.m_function->clone() )  
      , m_index     ( right.m_index             ) 
      , m_DIM       ( right.m_DIM               )
      , m_type      ( right.m_type              ) 
      , m_argument  ( right.m_DIM               )
      , m_result    ( GSL_NEGINF                )
      , m_error     ( GSL_POSINF                )
    {}
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    const NumericalDerivative::Type&
    NumericalDerivative::setType  ( const NumericalDerivative::Type& value ) 
    { m_type = value ; return type() ; }
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    Genfun::Derivative NumericalDerivative::partial( unsigned int idx ) const 
    {
      if( idx >= m_DIM ) 
        { Exception ( "::partial(i): invalid variable index" ) ; }
      const  AbsFunction& aux = 
        NumericalDerivative( *this , idx , type() ) ;
      return FunctionNoop( &aux ) ;
    }
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    double NumericalDerivative::operator() 
      ( const Argument& argument ) const
    {
      // reset the result and the error  
      m_result = GSL_NEGINF ;
      m_error  = GSL_POSINF ;
      
      // check the argument 
      if( argument.dimension() != m_DIM ) 
        { Exception ( "::operator():invalid argument size" ) ; };
      
      {for( size_t i  = 0 ; i < m_DIM ; ++i ){ m_argument[i] = argument[i];}}
      
      // create the helper object 
      GSL_Helper helper( *m_function , m_argument , m_index );
      
      gsl_function F ;
      F.function = &GSL_Adaptor ;
      F.params   = &helper                 ;
      
      double x       = argument[m_index];
      int    ierrno  = 0                   ;
      switch ( type() ) 
        {
        case Central  : 
          ierrno = gsl_diff_central  ( &F , x , &m_result , &m_error ) ; break ;
        case Forward  : 
          ierrno = gsl_diff_forward  ( &F , x , &m_result , &m_error ) ; break ;
        case Backward :
          ierrno = gsl_diff_backward ( &F , x , &m_result , &m_error ) ; break ;
        default:
          Exception ( "::operator(): invalid diffrentiation type " ) ;          
        }
      
      if( ierrno ) 
        { gsl_error ( " NumericalDerivative:: the error from gsl_diff_XXXX" ,
                      __FILE__ , __LINE__ , ierrno ) ; }
      
      return result() ;
    }
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    double NumericalDerivative::operator() ( const double  argument ) const
    {
      // reset the result and the error  
      m_result = GSL_NEGINF ;
      m_error  = GSL_POSINF ;
      
      // check the argument 
      if( 1 != m_DIM ) { Exception ( "operator(): invalid argument size " ); }

      Argument arg(1) ;
      arg[0] = argument ;
      return (*this)( arg ) ;
    }
    // ========================================================================
    
    // ========================================================================
    // ========================================================================
    StatusCode NumericalDerivative::Exception 
    ( const std::string& message ,  
      const StatusCode&  sc      ) const 
    {
      throw GaudiException( "NumericalDerivative" + message , 
                            "*GaudiMath*"         , sc      ) ;
      return sc ;
    }
    // ========================================================================
    
 
  } // end of namespace GaudiMathImplementation 

} // end of namespace Genfun (due to GSL) 
 
// ============================================================================
// The END 
// ============================================================================