Quick Links: ROOT Homepage Class Index Class Hierarchy

Sections: class description function members data members class charts

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="http://www.gnu.org/software/gsl/manual/html_node/Simulated-Annealing.html">
   GSL</A>.
   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)

public:

virtual	~GSLSimAnMinimizer()
virtual void	ROOT::Math::Minimizer::Clear()
virtual bool	ROOT::Math::Minimizer::Contour(unsigned int, unsigned int, unsigned int&, double, double)
virtual double	ROOT::Math::Minimizer::Correlation(unsigned int i, unsigned int j) const
virtual double	CovMatrix(unsigned int, unsigned int) const
virtual double	ROOT::Math::Minimizer::CovMatrix(unsigned int i, unsigned int j) const
virtual int	ROOT::Math::Minimizer::CovMatrixStatus() const
virtual double	Edm() const
virtual double	ROOT::Math::Minimizer::Edm() const
double	ROOT::Math::Minimizer::ErrorDef() const
virtual const double*	Errors() const
virtual const double*	ROOT::Math::Minimizer::Errors() const
virtual bool	GetMinosError(unsigned int, double&, double&)
virtual bool	ROOT::Math::Minimizer::GetMinosError(unsigned int, double& errLow, double& errUp)
virtual double	ROOT::Math::Minimizer::GlobalCC(unsigned int) const
ROOT::Math::GSLSimAnMinimizer	GSLSimAnMinimizer(int type = 0)
virtual bool	ROOT::Math::Minimizer::Hesse()
bool	ROOT::Math::Minimizer::IsValidError() const
unsigned int	ROOT::Math::Minimizer::MaxFunctionCalls()
unsigned int	ROOT::Math::Minimizer::MaxIterations()
virtual const double*	MinGradient() const
virtual const double*	ROOT::Math::Minimizer::MinGradient() const
virtual bool	Minimize()
virtual bool	ROOT::Math::Minimizer::Minimize()
virtual double	MinValue() const
virtual double	ROOT::Math::Minimizer::MinValue() const
virtual unsigned int	NCalls() const
virtual unsigned int	ROOT::Math::Minimizer::NCalls() const
virtual unsigned int	NDim() const
virtual unsigned int	ROOT::Math::Minimizer::NDim() const
virtual unsigned int	NFree() const
virtual unsigned int	ROOT::Math::Minimizer::NFree() const
int	ROOT::Math::Minimizer::PrintLevel() const
virtual void	ROOT::Math::Minimizer::PrintResults()
virtual bool	ProvidesError() const
virtual bool	ROOT::Math::Minimizer::ProvidesError() const
virtual bool	ROOT::Math::Minimizer::Scan(unsigned int, unsigned int&, double, double, double = 0, double = 0)
void	ROOT::Math::Minimizer::SetErrorDef(double up)
virtual bool	SetFixedVariable(unsigned int, const string&, double)
virtual bool	ROOT::Math::Minimizer::SetFixedVariable(unsigned int, const string&, double)
virtual void	SetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual void	SetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual void	ROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual void	ROOT::Math::Minimizer::SetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual bool	SetLimitedVariable(unsigned int ivar, const string& name, double val, double step, double, double)
virtual bool	ROOT::Math::Minimizer::SetLimitedVariable(unsigned int, const string&, double, double, double, double)
virtual bool	SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
virtual bool	ROOT::Math::Minimizer::SetLowerLimitedVariable(unsigned int ivar, const string& name, double val, double step, double lower)
void	ROOT::Math::Minimizer::SetMaxFunctionCalls(unsigned int maxfcn)
void	ROOT::Math::Minimizer::SetMaxIterations(unsigned int maxiter)
void	ROOT::Math::Minimizer::SetPrintLevel(int level)
void	ROOT::Math::Minimizer::SetStrategy(int strategyLevel)
void	ROOT::Math::Minimizer::SetTolerance(double tol)
virtual bool	SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
virtual bool	ROOT::Math::Minimizer::SetUpperLimitedVariable(unsigned int ivar, const string& name, double val, double step, double upper)
void	ROOT::Math::Minimizer::SetValidError(bool on)
virtual bool	SetVariable(unsigned int ivar, const string& name, double val, double step)
virtual bool	ROOT::Math::Minimizer::SetVariable(unsigned int ivar, const string& name, double val, double step)
virtual bool	SetVariableValue(unsigned int ivar, double val)
virtual bool	ROOT::Math::Minimizer::SetVariableValue(unsigned int, double)
virtual bool	SetVariableValues(const double* x)
virtual bool	ROOT::Math::Minimizer::SetVariableValues(const double* x)
int	ROOT::Math::Minimizer::Status() const
int	ROOT::Math::Minimizer::Strategy() const
double	ROOT::Math::Minimizer::Tolerance() const
virtual const double*	X() const
virtual const double*	ROOT::Math::Minimizer::X() const

private:

ROOT::Math::GSLSimAnMinimizer	GSLSimAnMinimizer(const ROOT::Math::GSLSimAnMinimizer&)
ROOT::Math::GSLSimAnMinimizer&	operator=(const ROOT::Math::GSLSimAnMinimizer& rhs)

Data Members

protected:

int	ROOT::Math::Minimizer::fDebug	print level
unsigned int	ROOT::Math::Minimizer::fMaxCalls	max number of funciton calls
unsigned int	ROOT::Math::Minimizer::fMaxIter	max number or iterations used to find the minimum
int	ROOT::Math::Minimizer::fStatus	status of minimizer
int	ROOT::Math::Minimizer::fStrategy	minimizer strategy
double	ROOT::Math::Minimizer::fTol	tolerance (absolute)
double	ROOT::Math::Minimizer::fUp	error scale
bool	ROOT::Math::Minimizer::fValidError	flag to control if errors have been validated (Hesse has been run in case of Minuit)

private:

map<unsigned int,std::pair<double,double> >	fBounds	map specifying the bound using as key the parameter index
unsigned int	fDim	dimension of the function to be minimized
double	fMinVal	minimum values
vector<std::string>	fNames
const ROOT::Math::IMultiGenFunction*	fObjFunc
bool	fOwnFunc	flag to indicate if objective function is managed
ROOT::Math::GSLSimAnnealing	fSolver
vector<double>	fSteps
vector<double>	fValues
vector<ROOT::Math::EMinimVariableType>	fVarTypes	vector specifyng the type of variables

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

GSLSimAnMinimizer(int type = 0)

      Default constructor

~GSLSimAnMinimizer()

      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; }