ROOT logo
ROOT » MATH » MATHMORE » ROOT::Math::GSLSimAnMinimizer

class ROOT::Math::GSLSimAnMinimizer: public ROOT::Math::Minimizer

   GSLSimAnMinimizer class for minimization using simulated annealing
   using the algorithm from
   <A HREF="">
   It implements the ROOT::Minimizer interface and
   a plug-in (name "GSLSimAn") exists to instantiate this class via the plug-in manager

   @ingroup Min1D

Function Members (Methods)

virtual voidROOT::Math::Minimizer::Clear()
virtual boolROOT::Math::Minimizer::Contour(unsigned int, unsigned int, unsigned int&, double*, double*)
virtual doubleROOT::Math::Minimizer::Correlation(unsigned int i, unsigned int j) const
virtual doubleCovMatrix(unsigned int, unsigned int) const
virtual doubleROOT::Math::Minimizer::CovMatrix(unsigned int i, unsigned int j) const
virtual intROOT::Math::Minimizer::CovMatrixStatus() const
virtual doubleEdm() const
virtual doubleROOT::Math::Minimizer::Edm() const
doubleROOT::Math::Minimizer::ErrorDef() const
virtual const double*Errors() const
virtual const double*ROOT::Math::Minimizer::Errors() const
virtual boolGetMinosError(unsigned int, double&, double&)
virtual boolROOT::Math::Minimizer::GetMinosError(unsigned int, double& errLow, double& errUp)
virtual doubleROOT::Math::Minimizer::GlobalCC(unsigned int) const
ROOT::Math::GSLSimAnMinimizerGSLSimAnMinimizer(int type = 0)
virtual boolROOT::Math::Minimizer::Hesse()
boolROOT::Math::Minimizer::IsValidError() const
unsigned intROOT::Math::Minimizer::MaxFunctionCalls()
unsigned intROOT::Math::Minimizer::MaxIterations()
virtual const double*MinGradient() const
virtual const double*ROOT::Math::Minimizer::MinGradient() const
virtual boolMinimize()
virtual boolROOT::Math::Minimizer::Minimize()
virtual doubleMinValue() const
virtual doubleROOT::Math::Minimizer::MinValue() const
virtual unsigned intNCalls() const
virtual unsigned intROOT::Math::Minimizer::NCalls() const
virtual unsigned intNDim() const
virtual unsigned intROOT::Math::Minimizer::NDim() const
virtual unsigned intNFree() const
virtual unsigned intROOT::Math::Minimizer::NFree() const
intROOT::Math::Minimizer::PrintLevel() const
virtual voidROOT::Math::Minimizer::PrintResults()
virtual boolProvidesError() const
virtual boolROOT::Math::Minimizer::ProvidesError() const
virtual boolROOT::Math::Minimizer::Scan(unsigned int, unsigned int&, double*, double*, double = 0, double = 0)
voidROOT::Math::Minimizer::SetErrorDef(double up)
virtual boolSetFixedVariable(unsigned int, const string&, double)
virtual boolROOT::Math::Minimizer::SetFixedVariable(unsigned int, const string&, double)
virtual voidSetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual voidSetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual voidROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual voidROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual boolSetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double, double)
virtual boolROOT::Math::Minimizer::SetLimitedVariable(unsigned int, const string&, double, double, double, double)
virtual boolSetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
virtual boolROOT::Math::Minimizer::SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
voidROOT::Math::Minimizer::SetMaxFunctionCalls(unsigned int maxfcn)
voidROOT::Math::Minimizer::SetMaxIterations(unsigned int maxiter)
voidROOT::Math::Minimizer::SetPrintLevel(int level)
voidROOT::Math::Minimizer::SetStrategy(int strategyLevel)
voidROOT::Math::Minimizer::SetTolerance(double tol)
virtual boolSetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
virtual boolROOT::Math::Minimizer::SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
voidROOT::Math::Minimizer::SetValidError(bool on)
virtual boolSetVariable(unsigned int ivar, const string& name, double val, double step)
virtual boolROOT::Math::Minimizer::SetVariable(unsigned int ivar, const string& name, double val, double step)
virtual boolSetVariableValue(unsigned int ivar, double val)
virtual boolROOT::Math::Minimizer::SetVariableValue(unsigned int, double)
virtual boolSetVariableValues(const double* x)
virtual boolROOT::Math::Minimizer::SetVariableValues(const double* x)
intROOT::Math::Minimizer::Status() const
intROOT::Math::Minimizer::Strategy() const
doubleROOT::Math::Minimizer::Tolerance() const
virtual const double*X() const
virtual const double*ROOT::Math::Minimizer::X() const

Data Members

intROOT::Math::Minimizer::fDebugprint level
unsigned intROOT::Math::Minimizer::fMaxCallsmax number of funciton calls
unsigned intROOT::Math::Minimizer::fMaxItermax number or iterations used to find the minimum
intROOT::Math::Minimizer::fStatusstatus of minimizer
intROOT::Math::Minimizer::fStrategyminimizer strategy
doubleROOT::Math::Minimizer::fToltolerance (absolute)
doubleROOT::Math::Minimizer::fUperror scale
boolROOT::Math::Minimizer::fValidErrorflag to control if errors have been validated (Hesse has been run in case of Minuit)
map<unsigned int,std::pair<double,double> >fBoundsmap specifying the bound using as key the parameter index
unsigned intfDimdimension of the function to be minimized
doublefMinValminimum values
const ROOT::Math::IMultiGenFunction*fObjFunc
boolfOwnFuncflag to indicate if objective function is managed
vector<ROOT::Math::EMinimVariableType>fVarTypesvector specifyng the type of variables

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

GSLSimAnMinimizer(int type = 0)
      Default constructor

      Destructor (no operations)

GSLSimAnMinimizer(const GSLSimAnMinimizer &)
 usually copying is non trivial, so we make this unaccessible

      Copy constructor

void SetFunction(const ROOT::Math::IMultiGenFunction & func)
 set the function to minimize
void SetFunction(const ROOT::Math::IMultiGradFunction & func)
 set gradient the function to minimize
bool SetVariable(unsigned int ivar, const string& name, double val, double step)
 set free variable
bool SetFixedVariable(unsigned int , const string& , double )
 set fixed variable (override if minimizer supports them )
bool SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
 set lower limit variable  (override if minimizer supports them )
bool SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
 set upper/lower limited variable (override if minimizer supports them )
bool SetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double , double )
bool SetVariableValue(unsigned int ivar, double val)
 set the value of an existing variable
bool SetVariableValues(const double* x)
bool Minimize()
 method to perform the minimization
double MinValue() const
 return minimum function value
{ return fMinVal; }
double Edm() const
 return expected distance reached from the minimum
const double * X() const
 return  pointer to X values at the minimum
{ return &fValues.front(); }
const double * MinGradient() const
 return pointer to gradient values at the minimum
{ return 0; }
unsigned int NCalls() const
 number of function calls to reach the minimum
{ return 0; }
unsigned int NDim() const
 this is <= Function().NDim() which is the total
 number of variables (free+ constrained ones)
{ return fDim; }
unsigned int NFree() const
 number of free variables (real dimension of the problem)
 this is <= Function().NDim() which is the total
{ return fDim; }
bool ProvidesError() const
 minimizer provides error and error matrix
{ return false; }
const double * Errors() const
 return errors at the minimum
{ return 0; }
double CovMatrix(unsigned int , unsigned int ) const
 return covariance matrices elements
       if the variable is fixed the matrix is zero
       The ordering of the variables is the same as in errors

{ return 0; }
bool GetMinosError(unsigned int , double& , double& )
 minos error for variable i, return false if Minos failed
{ return false; }