GSLDerivator.h

Go to the documentation of this file.

// @(#)root/mathmore:$Id: GSLDerivator.h 35018 2010-08-25 16:40:46Z moneta $
// Authors: L. Moneta, A. Zsenei   08/2005 

 /**********************************************************************
  *                                                                    *
  * Copyright (c) 2004 ROOT Foundation,  CERN/PH-SFT                   *
  *                                                                    *
  * This library is free software; you can redistribute it and/or      *
  * modify it under the terms of the GNU General Public License        *
  * as published by the Free Software Foundation; either version 2     *
  * of the License, or (at your option) any later version.             *
  *                                                                    *
  * This library is distributed in the hope that it will be useful,    *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of     *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
  * General Public License for more details.                           *
  *                                                                    *
  * You should have received a copy of the GNU General Public License  *
  * along with this library (see file COPYING); if not, write          *
  * to the Free Software Foundation, Inc., 59 Temple Place, Suite      *
  * 330, Boston, MA 02111-1307 USA, or contact the author.             *
  *                                                                    *
  **********************************************************************/

// Header file for class Derivator
// 
// class for calculating Derivative of functions
// 
// Created by: moneta  at Sat Nov 13 14:46:00 2004
// 
// Last update: Sat Nov 13 14:46:00 2004
// 
#ifndef ROOT_Math_GSLDerivator
#define ROOT_Math_GSLDerivator

/** 
@defgroup Deriv Numerical Differentiation
*/
 
#include "Math/GSLFunctionAdapter.h"
#include "GSLFunctionWrapper.h"


#include "Math/IFunctionfwd.h"
#include "Math/IFunction.h"

namespace ROOT {
namespace Math {


class GSLFunctionWrapper; 


/** 
    Class for computing numerical derivative of a function based on the GSL numerical algorithm 
    This class is implemented using the numerical derivatives algorithms provided by GSL
    (see <A HREF="http://www.gnu.org/software/gsl/manual/html_node/Numerical-Differentiation.html">GSL Online Manual</A> ).
    
    @ingroup Deriv
*/

class GSLDerivator {

public:
   /**
      Default Constructor of  a GSLDerivator class based on GSL numerical differentiation algorithms
   */
   GSLDerivator() : fStatus(0), fResult(0), fError(0)   {}

   /// destructor (no operations)
   virtual ~GSLDerivator() {}

//    // disable copying
// private: 

//    GSLDerivator(const GSLDerivator &);
//    GSLDerivator & operator = (const GSLDerivator &); 

// public: 



   /**
      Set the function for calculating the derivatives. 
      The function must implement the ROOT::Math::IGenFunction signature
    */
   void SetFunction(const IGenFunction &f);

   /** 
       Set the function f for evaluating the derivative using a GSL function pointer type 
       @param f :  free function pointer of the GSL required type
       @param p :  pointer to the object carrying the function state 
                    (for example the function object itself)
   */
   void SetFunction( GSLFuncPointer f, void * p = 0);
        
   /** 
       Computes the numerical derivative at a point x using an adaptive central 
       difference algorithm with a step size h. 
   */
   double EvalCentral( double x, double h); 

   /** 
       Computes the numerical derivative at a point x using an adaptive forward 
       difference algorithm with a step size h.
       The function is evaluated only at points greater than x and at x itself.
   */
   double EvalForward( double x, double h); 

   /** 
       Computes the numerical derivative at a point x using an adaptive backward 
       difference algorithm with a step size h.
       The function is evaluated only at points less than x and at x itself.
   */
   double EvalBackward( double x, double h); 

   /** @name --- Static methods --- **/

   /** 
       Computes the numerical derivative of a function f at a point x using an adaptive central 
       difference algorithm with a step size h
   */
   static double EvalCentral(const IGenFunction & f, double x, double h); 


   /** 
       Computes the numerical derivative of a function f at a point x using an adaptive forward 
       difference algorithm with a step size h.
       The function is evaluated only at points greater than x and at x itself
   */    
   static double EvalForward(const IGenFunction & f, double x, double h);

   /** 
       Computes the numerical derivative of a function f at a point x using an adaptive backward 
       difference algorithm with a step size h.
       The function is evaluated only at points less than x and at x itself
   */
    
   static double EvalBackward(const IGenFunction & f, double x, double h); 

    

   /**
      return the error status of the last integral calculation
   */     
   int Status() const; 

   /**
      return  the result of the last derivative calculation
   */
   double Result() const; 

   /**
      return the estimate of the absolute error of the last derivative calculation
   */
   double Error() const; 


private: 

   int fStatus;
   double fResult; 
   double fError; 

   GSLFunctionWrapper fFunction;  

}; 




} // namespace Math
} // namespace ROOT


#endif /* ROOT_Math_GSLDerivator */

---