ROOT logo
ROOT » MATH » MINUIT » TLinearMinimizer

class TLinearMinimizer: public ROOT::Math::Minimizer

  TLinearMinimizer, simple class implementing the ROOT::Math::Minimizer interface using
  This class uses TLinearFitter to find directly (by solving a system of linear equations)
  the minimum of a
  least-square function which has a linear dependence in the fit parameters.
  This class is not used directly, but via the ROOT::Fitter class, when calling the
  LinearFit method. It is instantiates using the plug-in manager (plug-in name is "Linear")

Function Members (Methods)

TLinearMinimizer(int type = 0)
TLinearMinimizer(const char* type)
static TClass*Class()
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 i, unsigned int j) const
virtual intCovMatrixStatus() const
virtual doubleEdm() const
doubleROOT::Math::Minimizer::ErrorDef() const
virtual const double*Errors() const
virtual boolROOT::Math::Minimizer::GetCovMatrix(double*) const
virtual boolROOT::Math::Minimizer::GetHessianMatrix(double*) const
virtual boolROOT::Math::Minimizer::GetMinosError(unsigned int, double& errLow, double& errUp, int = 0)
virtual doubleROOT::Math::Minimizer::GlobalCC(unsigned int) const
virtual boolROOT::Math::Minimizer::Hesse()
virtual TClass*IsA() const
boolROOT::Math::Minimizer::IsValidError() const
unsigned intROOT::Math::Minimizer::MaxFunctionCalls() const
unsigned intROOT::Math::Minimizer::MaxIterations() const
virtual const double*MinGradient() const
virtual boolMinimize()
virtual doubleMinValue() const
virtual unsigned intNCalls() const
virtual unsigned intNDim() const
virtual unsigned intNFree() const
virtual ROOT::Math::MinimizerOptionsROOT::Math::Minimizer::Options() const
doubleROOT::Math::Minimizer::Precision() const
intROOT::Math::Minimizer::PrintLevel() const
virtual voidROOT::Math::Minimizer::PrintResults()
virtual boolProvidesError() 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 voidSetFunction(const ROOT::Math::IMultiGenFunction& func)
virtual voidSetFunction(const ROOT::Math::IMultiGradFunction& func)
virtual boolROOT::Math::Minimizer::SetLimitedVariable(unsigned int, const string&, double, double, double, double)
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::SetOptions(const ROOT::Math::MinimizerOptions& opt)
voidROOT::Math::Minimizer::SetPrecision(double prec)
voidROOT::Math::Minimizer::SetPrintLevel(int level)
voidROOT::Math::Minimizer::SetStrategy(int strategyLevel)
voidROOT::Math::Minimizer::SetTolerance(double tol)
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, const string&, double, double)
virtual boolROOT::Math::Minimizer::SetVariableValue(unsigned int, double)
virtual boolROOT::Math::Minimizer::SetVariableValues(const double* x)
virtual voidShowMembers(TMemberInspector& insp)
intROOT::Math::Minimizer::Status() const
intROOT::Math::Minimizer::Strategy() const
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
doubleROOT::Math::Minimizer::Tolerance() const
virtual intROOT::Math::Minimizer::VariableIndex(const string&) const
virtual stringROOT::Math::Minimizer::VariableName(unsigned int) const
virtual const double*X() const

Data Members

intROOT::Math::Minimizer::fDebugprint level
unsigned intROOT::Math::Minimizer::fMaxCallsmax number of function 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)
unsigned intfDim
unsigned intfNFree
const ROOT::Math::IGradientFunctionMultiDim*fObjFunc

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TLinearMinimizer(int type = 0)
 Default constructor implementation.
 type is not used - needed for consistency with other minimizer plug-ins
TLinearMinimizer(const char* type)
 constructor passing a type of algorithm, (supported now robust via LTS regression)
 Destructor implementation.
TLinearMinimizer(const TLinearMinimizer& )
 Implementation of copy constructor.
void SetFunction(const ROOT::Math::IMultiGenFunction & )
 Set function to be minimized. Flag an error since only support Gradient objective functions
void SetFunction(const ROOT::Math::IMultiGradFunction & objfunc)
 Set the function to be minimized. The function must be a Chi2 gradient function
 When performing a linear fit we need the basis functions, which are the partial derivatives with respect to the parameters of the model function.
bool SetFixedVariable(unsigned int , const string& , double )
 set a fixed variable.
bool Minimize()
 find directly the minimum of the chi2 function
 solving the linear equation. Use  TVirtualFitter::Eval.
bool SetVariable(unsigned int , const string& , double , double )
 set free variable (dummy impl. )
{ return false; }
double MinValue() const
 return minimum function value
{ return fMinVal; }
double Edm() const
 return expected distance reached from the minimum
{ return 0; }
const double * X() const
 return  pointer to X values at the minimum
{ return &fParams.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 fNFree; }
bool ProvidesError() const
 minimizer provides error and error matrix
{ return true; }
const double * Errors() const
 return errors at the minimum
{ return (fErrors.empty()) ? 0 : &fErrors.front(); }
double CovMatrix(unsigned int i, unsigned int j) 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

int CovMatrixStatus() const
 return covariance matrix status