GSLDerivator.h

Go to the documentation of this file.

// @(#)root/mathmore:$Id$
// 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 */