MultiNumGradFunction.h

Go to the documentation of this file.

// @(#)root/mathmore:$Id$
// Author: L. Moneta Wed Dec 20 14:36:31 2006

/**********************************************************************
 *                                                                    *
 * Copyright (c) 2006  LCG ROOT Math Team, 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 MultiNumGradFunction

#ifndef ROOT_Math_MultiNumGradFunction
#define ROOT_Math_MultiNumGradFunction


#include "Math/IFunction.h"

#include "Math/WrappedFunction.h"


namespace ROOT {

   namespace Math {


/**
   MultiNumGradFunction class to wrap a normal function in  a
   gradient function using numerical gradient calculation
   provided by the class Derivator (based on GSL numerical derivation)


   @ingroup MultiMin
*/
class MultiNumGradFunction : public IMultiGradFunction {

public:


   /**
     Constructor from a IMultiGenFunction interface
   */
   MultiNumGradFunction (const IMultiGenFunction & f) :
      fFunc(&f),
      fDim(f.NDim() ),
      fNCalls(0),
      fOwner(false)
   {}

   /**
     Constructor from a generic function (pointer or reference) and number of dimension
     implementiong operator () (double * x)
   */

   template<class FuncType>
   MultiNumGradFunction (FuncType f, int n) :
      fDim( n ),
      fNCalls(0),
      fOwner(true)
   {
      // create a wrapped function
      fFunc = new ROOT::Math::WrappedMultiFunction<FuncType> (f, n);
   }

   /**
      Destructor (no operations)
   */
   ~MultiNumGradFunction ()  {
      if (fOwner) delete fFunc;
   }


   // method inheritaed from IFunction interface

   unsigned int NDim() const { return fDim; }

   unsigned int NCalls() const { return fNCalls; }

   IMultiGenFunction * Clone() const {
      if (!fOwner)
         return new MultiNumGradFunction(*fFunc);
      else {
         // we need to copy the pointer to the wrapped function
         MultiNumGradFunction * f =  new MultiNumGradFunction(*(fFunc->Clone()) );
         f->fOwner = true;
         return f;
      }
   }

   // set ownership
   void SetOwnership(bool on = true) { fOwner = on;  }

   /// precision value used for calculating the derivative step-size
   /// h = eps * |x|. The default is 0.001, give a smaller in case function chanes rapidly
   static void SetDerivPrecision(double eps);

   /// get precision value used for calculating the derivative step-size
   static double GetDerivPrecision();


private:


   double DoEval(const double * x) const {
      fNCalls++;
      return (*fFunc)(x);
   }

   // calculate derivative using mathcore derivator
   double DoDerivative (const double * x, unsigned int icoord  ) const;

   // adapat internal function type to IMultiGenFunction needed by derivative calculation
   const IMultiGenFunction * fFunc;
   unsigned int fDim;
   mutable unsigned int fNCalls;
   bool fOwner;

   static double fgEps;          // epsilon used in derivative calculation h ~ eps |x|

};

   } // end namespace Math

} // end namespace ROOT


#endif /* ROOT_Math_NumGradFunction */