class ROOT::Fit::Fitter

      Default constructor

      Destructor

      Copy constructor (disabled, class is not copyable)

       fit a data set using any  generic model  function
       Pre-requisite on the function:

       fit a binned data set (default method: use chi2)
       To be implemented option to do likelihood bin fit

       fit an binned data set using loglikelihood method

      Likelihood fit

       fit a data set using any  generic model  function
       Pre-requisite on the function:

      Fit using the a generic FCN function as a C++ callable object implementing
      double () (const double *)
      Note that the function dimension (i.e. the number of parameter) is needed in this case
      For the options see documentation for following methods FitFCN(IMultiGenFunction & fcn,..)

      Set a generic FCN function as a C++ callable object implementing
      double () (const double *)
      Note that the function dimension (i.e. the number of parameter) is needed in this case
      For the options see documentation for following methods FitFCN(IMultiGenFunction & fcn,..)

      Fit using the given FCN function represented by a multi-dimensional function interface
      (ROOT::Math::IMultiGenFunction).
      Give optionally the initial arameter values, data size to have the fit Ndf correctly
      set in the FitResult and flag specifying if it is a chi2 fit.
      Note that if the parameters values are not given (params=0) the
      current parameter settings are used. The parameter settings can be created before
      by using the FitConfig::SetParamsSetting. If they have not been created they are created
      automatically when the params pointer is not zero.
      Note that passing a params != 0 will set the parameter settings to the new value AND also the
      step sizes to some pre-defined value (stepsize = 0.3 * abs(parameter_value) )

       Fit using a FitMethodFunction interface. Same as method above, but now extra information
       can be taken from the function class


      Set the FCN function represented by a multi-dimensional function interface
      (ROOT::Math::IMultiGenFunction) and optionally the initial parameters
      See also note above for the initial parameters for FitFCN

       Set the objective function (FCN)  using a FitMethodFunction interface.
       Same as method above, but now extra information can be taken from the function class

      Fit using the given FCN function representing a multi-dimensional gradient function
      interface (ROOT::Math::IMultiGradFunction). In this case the minimizer will use the
      gradient information provided by the function.
      For the options same consideration as in the previous method

       Fit using a FitMethodGradFunction interface. Same as method above, but now extra information
       can be taken from the function class

      Set the FCN function represented by a multi-dimensional gradient function interface
      (ROOT::Math::IMultiGenFunction) and optionally the initial parameters
      See also note above for the initial parameters for FitFCN

      Perform a simple FCN evaluation. FitResult will be modified and contain  the value of the FCN

      do a linear fit on a set of bin-data

       Set the fitted function (model function) from a parametric function interface

      Set the fitted function from a parametric 1D function interface

      perform an error analysis on the result using the Hessian
      Errors are obtaied from the inverse of the Hessian matrix
      To be called only after fitting and when a minimizer supporting the Hessian calculations is used
      otherwise an error (false) is returned.
      A new  FitResult with the Hessian result will be produced

      perform an error analysis on the result using MINOS
      To be called only after fitting and when a minimizer supporting MINOS is used
      otherwise an error (false) is returned.
      The result will be appended in the fit result class
      Optionally a vector of parameter indeces can be passed for selecting
      the parameters to analyse using FitConfig::SetMinosErrors

      query if fit is binned. In cse of false teh fit can be unbinned
      or is not defined (like in case of fitting through a ::FitFCN)

      return pointer to last used minimizer
      (is NULL in case fit is not yet done)
      This pointer will be valid as far as the data, the objective function
      and the fitter class  have not been deleted.
      To be used only after fitting.
      The pointer should not be stored and will be invalided after performing a new fitting.
      In this case a new instance of ROOT::Math::Minimizer will be re-created and can be
      obtained calling again GetMinimizer()

      return pointer to last used objective function
      (is NULL in case fit is not yet done)
      This pointer will be valid as far as the data and the fitter class
      have not been deleted. To be used after the fitting.
      The pointer should not be stored and will be invalided after performing a new fitting.
      In this case a new instance of the function pointer will be re-created and can be
      obtained calling again GetFCN()

      apply correction in the error matrix for the weights for likelihood fits
      This method can be called only after a fit and it assumes now that the
      passed function (loglw2) is a log-likelihood function impelemented using the
      sum of weight squared

 linear least square fit

 initialize the minimizer

 do minimization

 do minimization after having set obj function

 update config after fit

 get function calls from the FCN