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 a new free variable

 set a new lower limit variable  (override if minimizer supports them )

 set a new upper limit variable (override if minimizer supports them )

 set a new fixed variable (override if minimizer supports them )

 set the value of an already existing variable

 set the values of all existing variables (array must be dimensioned to the size of the existing parameters)

 set the step size of an already existing variable

 set the lower-limit of an already existing variable

 set the upper-limit of an already existing variable

 set the limits of an already existing variable

 fix an existing variable

 release an existing variable

 query if an existing variable is fixed (i.e. considered constant in the minimization)
 note that by default all variables are not fixed

 get variable settings in a variable object (like ROOT::Fit::ParamsSettings)

 set the initial range of an existing variable

 method to perform the minimization

 return minimum function value

 return  pointer to X values at the minimum

 return expected distance reached from the minimum (re-implement if minimizer provides it

 return pointer to gradient values at the minimum

 number of function calls to reach the minimum

 number of iterations 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
 (re-implement if minimizer supports bounded parameters)

 minimizer provides error and error matrix

 return errors at the minimum

 return covariance matrices element for variables ivar,jvar
       if the variable is fixed the return value is zero
       The ordering of the variables is the same as in the parameter and errors vectors

       Fill the passed array with the  covariance matrix elements
       if the variable is fixed or const the value is zero.
       The array will be filled as cov[i *ndim + j]
       The ordering of the variables is the same as in errors and parameter value.
       This is different from the direct interface of Minuit2 or TMinuit where the
       values were obtained only to variable parameters

       Fill the passed array with the Hessian matrix elements
       The Hessian matrix is the matrix of the second derivatives
       and is the inverse of the covariance matrix
       If the variable is fixed or const the values for that variables are zero.
       The array will be filled as h[i *ndim + j]

return status of covariance matrix
 using Minuit convention {0 not calculated 1 approximated 2 made pos def , 3 accurate}
 Minimizer who implements covariance matrix calculation will re-implement the method

      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
      and the lower and upper errors are returned in errLow and errUp
      An extra flag  specifies if only the lower (option=-1) or the upper (option=+1) error calculation is run
      (This feature is not yet implemented)

      perform a full calculation of the Hessian matrix for error calculation

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

      find the contour points (xi, xj) of the function for parameter ivar and jvar 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)
 return an empty string if variable is not found

 get index of variable given a variable given a name
 return -1 if variable is not found

 minimizer configuration parameters 
 set print level

  max number of function calls

 max iterations

 absolute tolerance

 precision of minimizer in the evaluation of the objective function
 ( a value <=0 corresponds to the let the minimizer choose its default one)

 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 in the minimizer the objective function evaluation precision
 ( a value <=0 means the minimizer will choose its optimal value automatically, i.e. default case)

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)

 set all options in one go

 reset the defaut options (defined in MinimizerOptions)