class ROOT::Math::Minimizer

      Destructor (no operations)

 reset for consecutive minimizations - implement if needed

 set the function to minimize

 set a function to minimize using gradient

 set free variable

 set upper limit variable (override if minimizer supports them )

 set fixed variable (override if minimizer supports them )

 set the value of an existing variable

 method to perform the minimization

 return minimum function value

 return expected distance reached from the minimum

 return  pointer to X values at the minimum

 return pointer to gradient values at the minimum

 number of function calls to reach the minimum

 this is <= Function().NDim() which is the total
 number of variables (free+ constrained ones)

 number of free variables (real dimension of the problem)
 this is <= Function().NDim() which is the total

 minimizer provides error and error matrix

 return errors at the minimum

 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 correlation coefficient between variable i and j.
      If the variable is fixed or const the return value is zero

      return global correlation coefficient for variable i
      This is a number between zero and one which gives
      the correlation between the i-th parameter  and that linear combination of all
      other parameters which is most strongly correlated with i.
      Minimizer must overload method if implemented

      minos error for variable i, return false if Minos failed or not supported

      scan function minimum for variable i. Variable and funciton must be set before using Scan
      Return false if an error or if minimizer does not support this funcitonality

      find the contour points (xi,xj) of the function for parameter i and j around the minimum
      The contour will be find for value of the function = Min + ErrorUp();

 return reference to the objective function
virtual const ROOT::Math::IGenFunction & Function() const = 0;
 print the result according to set level (implemented for TMinuit for mantaining Minuit-style printing)

 get name of variables (override if minimizer support storing of variable names)
virtual std::string VariableName(unsigned int ivar) const { return "x_" + ROOT::Math::Util::ToString(ivar); }
 minimizer configuration parameters 
 set print level

  max number of function calls

 max iterations

 absolute tolerance

 strategy

 status code of minimizer

 return the statistical scale used for calculate the error
 is typically 1 for Chi2 and 0.5 for likelihood minimization

return true if Minimizer has performed a detailed error validation (e.g. run Hesse for Minuit)

 set print level

set maximum of function calls

 set maximum iterations (one iteration can have many function calls)

 set the tolerance

set the strategy

 set scale for calculating the errors

 flag to check if minimizer needs to perform accurate error analysis (e.g. run Hesse for Minuit)