// @(#)root/mathcore:$Id: IFunction.h 24482 2008-06-23 15:33:08Z moneta $
// Authors: L. Moneta 11/2006
/**********************************************************************
* *
* Copyright (c) 2006 , LCG ROOT MathLib Team *
* *
* *
**********************************************************************/
// Header file for function interfaces
//
// Generic Interfaces for one or multi-dimensional functions
//
// Created by: Lorenzo Moneta : Wed Nov 13 2006
//
//
#ifndef ROOT_Math_IFunction
#define ROOT_Math_IFunction
/**
@defgroup CppFunctions Function Classes and Interfaces
Interfaces (abstract classes) and Base classes used in MathCore and MathMore numerical methods
for describing function classes. They define function and gradient evaluation and as well the
functionality for dealing with parameters in the case of parametric functions which are used for
fitting and data modeling.
Included are also adapter classes, such as functors, to wrap generic callable C++ objects
in the desired interface.
*/
//typedefs and tags definitions
#ifndef ROOT_Math_IFunctionfwd
#include "Math/IFunctionfwd.h"
#endif
namespace ROOT {
namespace Math {
/**
@defgroup GenFunc Interfaces for generic function evaluation
@ingroup CppFunctions
*/
//___________________________________________________________________________________
/**
Documentation for the abstract class IBaseFunctionMultiDim.
Interface (abstract class) for generic functions objects of multi-dimension
Provides a method to evaluate the function given a vector of coordinate values,
by implementing operator() (const double *).
In addition it defines the interface for copying functions via the pure virtual method Clone()
and the interface for getting the function dimension via the NDim() method.
Derived classes must implement the pure private virtual method DoEval(const double *) for the
function evaluation in addition to NDim() and Clone().
@ingroup GenFunc
*/
class IBaseFunctionMultiDim {
public:
typedef IBaseFunctionMultiDim BaseFunc;
IBaseFunctionMultiDim() {}
/**
virtual destructor
*/
virtual ~IBaseFunctionMultiDim() {}
/**
Clone a function.
Each derived class must implement his version of the Clone method
*/
virtual IBaseFunctionMultiDim * Clone() const = 0;
/**
Retrieve the dimension of the function
*/
virtual unsigned int NDim() const = 0;
/**
Evaluate the function at a point x[].
Use the pure virtual private method DoEval which must be implemented by the sub-classes
*/
double operator() (const double* x) const {
return DoEval(x);
}
#ifdef LATER
/**
Template method to eveluate the function using the begin of an iterator
User is responsible to provide correct size for the iterator
*/
template
double operator() (const Iterator it ) const {
return DoEval( &(*it) );
}
#endif
private:
/**
Implementation of the evaluation function. Must be implemented by derived classes
*/
virtual double DoEval(const double * x) const = 0;
};
//___________________________________________________________________________________
/**
Interface (abstract class) for generic functions objects of one-dimension
Provides a method to evaluate the function given a value (simple double)
by implementing operator() (const double ).
In addition it defines the interface for copying functions via the pure virtual method Clone().
Derived classes must implement the pure virtual private method DoEval(double ) for the
function evaluation in addition to Clone().
An interface for evaluating the function passing a vector (like for multidim functions) is also
provided
@ingroup GenFunc
*/
class IBaseFunctionOneDim {
public:
typedef IBaseFunctionOneDim BaseFunc;
IBaseFunctionOneDim() {}
/**
virtual destructor
*/
virtual ~IBaseFunctionOneDim() {}
/**
Clone a function.
Each derived class will implement his version of the provate DoClone method
*/
virtual IBaseFunctionOneDim * Clone() const = 0;
/**
Evaluate the function at a point x
Use the a pure virtual private method DoEval which must be implemented by sub-classes
*/
double operator() (double x) const {
return DoEval(x);
}
/**
Evaluate the function at a point x[].
Compatible method with multi-dimensional functions
*/
double operator() (const double * x) const {
return DoEval(*x);
}
private:
// use private virtual inheritance
/// implementation of the evaluation function. Must be implemented by derived classes
virtual double DoEval(double x) const = 0;
};
//-------- GRAD functions---------------------------
//___________________________________________________________________________________
/**
Gradient interface (abstract class) defining the signature for calculating the gradient of a
multi-dimensional function.
Three methods are provided:
- Gradient(const double *x, double * grad) evaluate the full gradient vector at the vector value x
- Derivative(const double * x, int icoord) evaluate the partial derivative for the icoord coordinate
- FdF(const double *x, double &f, double * g) evaluate at the same time gradient and function/
Concrete classes should derive from ROOT::Math::IGradientFunctionMultiDim and not from this class.
@ingroup GenFunc
*/
class IGradientMultiDim {
public:
/// virual destructor
virtual ~IGradientMultiDim() {}
/**
Evaluate all the vector of function derivatives (gradient) at a point x.
Derived classes must re-implement if it is more efficient than evaluting one at a time
*/
virtual void Gradient(const double *x, double * grad) const = 0;
/**
Return the partial derivative with respect to the passed coordinate
*/
double Derivative(const double * x, unsigned int icoord = 0) const {
return DoDerivative(x, icoord);
}
/**
Optimized method to evaluate at the same time the function value and derivative at a point x.
Often both value and derivatives are needed and it is often more efficient to compute them at the same time.
Derived class should implement this method if performances play an important role and if it is faster to
evaluate value and derivative at the same time
*/
virtual void FdF (const double * x, double & f, double * df) const = 0;
private:
/**
function to evaluate the derivative with respect each coordinate. To be implemented by the derived class
*/
virtual double DoDerivative(const double * x, unsigned int icoord ) const = 0;
};
//___________________________________________________________________________________
/**
Specialized Gradient interface(abstract class) for one dimensional functions
It provides a method to evaluate the derivative of the function, Derivative and a
method to evaluate at the same time the function and the derivative FdF
Concrete classes should derive from ROOT::Math::IGradientFunctionOneDim and not from this class.
@ingroup GenFunc
*/
class IGradientOneDim {
public:
/// virtual destructor
virtual ~IGradientOneDim() {}
/**
Return the derivative of the function at a point x
Use the private method DoDerivative
*/
double Derivative(double x ) const {
return DoDerivative(x );
}
/**
Optimized method to evaluate at the same time the function value and derivative at a point x.
Often both value and derivatives are needed and it is often more efficient to compute them at the same time.
Derived class should implement this method if performances play an important role and if it is faster to
evaluate value and derivative at the same time
*/
virtual void FdF (double x, double & f, double & df) const = 0;
/**
Compatibility method with multi-dimensional interface for partial derivative
*/
double Derivative(const double * x) const {
return DoDerivative( *x);
}
/**
Compatibility method with multi-dimensional interface for Gradient
*/
void Gradient(const double * x, double *g) const {
g[0] = DoDerivative( *x);
}
/**
Compatibility method with multi-dimensional interface for Gradient and function evaluation
*/
void FdF(const double * x, double & f, double * df) const {
FdF(*x, f, *df);
}
private:
/**
function to evaluate the derivative with respect each coordinate. To be implemented by the derived class
*/
virtual double DoDerivative(double x ) const = 0;
};
//___________________________________________________________________________________
/**
Interface (abstract class) for multi-dimensional functions providing a gradient calculation.
It implements both the ROOT::Math::IBaseFunctionMultiDim and
ROOT::Math::IGradientMultiDim interfaces.
The method ROOT::Math::IFunction::Gradient calculates the full gradient vector,
ROOT::Math::IFunction::Derivative calculates the partial derivative for each coordinate and
ROOT::Math::Fdf calculates the gradient and the function value at the same time.
The pure private virtual method DoDerivative() must be implemented by the derived classes, while
Gradient and FdF are by default implemented using DoDerivative, butthey can be overloaded by the
derived classes to improve the efficiency in the derivative calculation.
@ingroup GenFunc
*/
class IGradientFunctionMultiDim :
virtual public IBaseFunctionMultiDim ,
public IGradientMultiDim {
public:
typedef IBaseFunctionMultiDim BaseFunc;
typedef IGradientMultiDim BaseGrad;
/**
Virtual Destructor (no operations)
*/
virtual ~IGradientFunctionMultiDim () {}
/**
Evaluate all the vector of function derivatives (gradient) at a point x.
Derived classes must re-implement it if more efficient than evaluting one at a time
*/
virtual void Gradient(const double *x, double * grad) const {
unsigned int ndim = NDim();
for (unsigned int icoord = 0; icoord < ndim; ++icoord)
grad[icoord] = BaseGrad::Derivative(x,icoord);
}
using BaseFunc::NDim;
/**
Optimized method to evaluate at the same time the function value and derivative at a point x.
Often both value and derivatives are needed and it is often more efficient to compute them at the same time.
Derived class should implement this method if performances play an important role and if it is faster to
evaluate value and derivative at the same time
*/
virtual void FdF (const double * x, double & f, double * df) const {
f = BaseFunc::operator()(x);
Gradient(x,df);
}
};
//___________________________________________________________________________________
/**
Interface (abstract class) for one-dimensional functions providing a gradient calculation.
It implements both the ROOT::Math::IBaseFunctionOneDim and
ROOT::Math::IGradientOneDim interfaces.
The method ROOT::Math::IFunction::Derivative calculates the derivative and
ROOT::Math::Fdf calculates the derivative and the function values at the same time.
The pure private virtual method DoDerivative() must be implemented by the derived classes, while
FdF is by default implemented using DoDerivative, but it can be overloaded by the
derived classes to improve the efficiency in the derivative calculation.
@ingroup GenFunc
*/
//template <>
class IGradientFunctionOneDim :
virtual public IBaseFunctionOneDim ,
public IGradientOneDim {
public:
typedef IBaseFunctionOneDim BaseFunc;
typedef IGradientOneDim BaseGrad;
/**
Virtual Destructor (no operations)
*/
virtual ~IGradientFunctionOneDim () {}
/**
Optimized method to evaluate at the same time the function value and derivative at a point x.
Often both value and derivatives are needed and it is often more efficient to compute them at the same time.
Derived class should implement this method if performances play an important role and if it is faster to
evaluate value and derivative at the same time
*/
virtual void FdF (double x, double & f, double & df) const {
f = operator()(x);
df = Derivative(x);
}
};
} // namespace Math
} // namespace ROOT
#endif /* ROOT_Math_IGenFunction */