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 lower limit variable  (override if minimizer supports them )

 set upper limit variable (override if minimizer supports them )

 set fixed variable (override if minimizer supports them )

 set the value of an existing variable

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

 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

       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 (runopt=-1) or the upper (runopt=+1) error calculation is run
      (This feature isnot 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 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)
 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)

 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)