class TFumili: public TVirtualFitter

 maxpar is the maximum number of parameters used with TFumili object

   Allocates memory for internal arrays. Called by TFumili::TFumili

 TFumili destructor

 return a chisquare equivalent

 Resets all parameter names, values and errors to zero

 Argument opt is ignored

 NB: this procedure doesn't reset parameter limits

 Deallocates memory. Called from destructor TFumili::~TFumili

 Calculates partial derivatives of theoretical function

 Input:
    fX  - vector of data point
 Output:
    DF - array of derivatives

 ARITHM.F
 Converted from CERNLIB

 Evaluate the minimisation function
  Input parameters:
    npar:    number of currently variable parameters
    par:     array of (constant and variable) parameters
    flag:    Indicates what is to be calculated
    grad:    array of gradients
  Output parameters:
    fval:    The calculated function value.
    grad:    The vector of first derivatives.

 The meaning of the parameters par is of course defined by the user,
 who uses the values of those parameters to calculate his function value.
 The starting values must be specified by the user.

 Inside FCN user has to define Z-matrix by means TFumili::GetZ
  and TFumili::Derivatives,
 set theoretical function by means of TFumili::SetUserFunc,
 but first - pass number of parameters by TFumili::SetParNumber

 Later values are determined by Fumili as it searches for the minimum
 or performs whatever analysis is requested by the user.

 The default function calls the function specified in SetFCN

 Evaluate theoretical function
 df: array of partial derivatives
 X:  vector of theoretical function argument

  Execute MINUIT commands. MINImize, SIMplex, MIGrad and FUMili all
  will call TFumili::Minimize method.

  For full command list see
  MINUIT. Reference Manual. CERN Program Library Long Writeup D506.

  Improvement and errors calculation are not yet implemented as well
  as Monte-Carlo seeking and minimization.
  Contour commands are also unsupported.

  command   : command string
  args      : array of arguments
  nargs     : number of arguments

 Called from TFumili::ExecuteCommand in case
 of "SET xxx" and "SHOW xxx".

 Fixes parameter number ipar

 return a pointer to the covariance matrix

 return element i,j from the covariance matrix

 return the total number of parameters (free + fixed)

 return the number of free parameters

 return error of parameter ipar

 return current value of parameter ipar

 Get various ipar parameter attributs:

 cname:    parameter name
 value:    parameter value
 verr:     parameter error
 vlow:     lower limit
 vhigh:    upper limit
 WARNING! parname must be suitably dimensionned in the calling function.

 return name of parameter ipar

 Return errors after MINOs
 not implemented

 return global fit parameters
   amin     : chisquare
   edm      : estimated distance to minimum
   errdef
   nvpar    : number of variable parameters
   nparx    : total number of parameters

 return Sum(log(i) i=0,n
 used by log likelihood fits

 Inverts packed diagonal matrix Z by square-root method.
  Matrix elements corresponding to
 fix parameters are removed.

 n: number of variable parameters

return kTRUE if parameter ipar is fixed, kFALSE othersise)

*
         FUMILI
  Based on ideas, proposed by I.N. Silin
    [See NIM A440, 2000 (p431)]
 converted from FORTRAN to C  by
     Sergey Yaschenko <s.yaschenko@fz-juelich.de>

*

 This function is called after setting theoretical function
 by means of TFumili::SetUserFunc and initializing parameters.
 Optionally one can set FCN function (see TFumili::SetFCN and TFumili::Eval)
 If FCN is undefined then user has to provide data arrays by calling
  TFumili::SetData procedure.

 TFumili::Minimize return following values:
    0  - fit is converged
   -2  - function is not decreasing (or bad derivatives)
   -3  - error estimations are infinite
   -4  - maximum number of iterations is exceeded

 Prints fit results.

 ikode is the type of printing parameters
 p is function value

  ikode = 1   - print values, errors and limits
  ikode = 2   - print values, errors and steps
  ikode = 3   - print values, errors, steps and derivatives
  ikode = 4   - print only values and errors

 Releases parameter number ipar

 Sets pointer to data array provided by user.
 Necessary if SetFCN is not called.

 numpoints:    number of experimental points
 vecsize:      size of data point vector + 2
               (for N-dimensional fit vecsize=N+2)
 exdata:       data array with following format

   exdata[0] = ExpValue_0     - experimental data value number 0
   exdata[1] = ExpSigma_0     - error of value number 0
   exdata[2] = X_0[0]
   exdata[3] = X_0[1]

   exdata[vecsize-1] = X_0[vecsize-3]
   exdata[vecsize]   = ExpValue_1
   exdata[vecsize+1] = ExpSigma_1
   exdata[vecsize+2] = X_1[0]

   exdata[vecsize*(numpoints-1)] = ExpValue_(numpoints-1)

   exdata[vecsize*numpoints-1] = X_(numpoints-1)[vecsize-3]

 ret fit method (chisquare or loglikelihood)

 Sets for prameter number ipar initial parameter value,
 name parname, initial error verr and limits vlow and vhigh
 If vlow = vhigh but not equil to zero, parameter will be fixed.
 If vlow = vhigh = 0, parameter is released and its limits are discarded

  Evaluates objective function ( chi-square ), gradients and
  Z-matrix using data provided by user via TFumili::SetData

  Minimization function for H1s using a Chisquare method
  Default method (function evaluated at center of bin)
  for each point the cache contains the following info
    -1D : bc,e,xc  (bin content, error, x of center of bin)
    -2D : bc,e,xc,yc
    -3D : bc,e,xc,yc,zc

  Minimization function for H1s using a Chisquare method
  The "I"ntegral method is used
  for each point the cache contains the following info
    -1D : bc,e,xc,xw  (bin content, error, x of center of bin, x bin width of bin)
    -2D : bc,e,xc,xw,yc,yw
    -3D : bc,e,xc,xw,yc,yw,zc,zw

  Minimization function for H1s using a Likelihood method*-*-*-*-*-*
     Basically, it forms the likelihood by determining the Poisson
     probability that given a number of entries in a particular bin,
     the fit would predict it's value.  This is then done for each bin,
     and the sum of the logs is taken as the likelihood.
  Default method (function evaluated at center of bin)
  for each point the cache contains the following info
    -1D : bc,e,xc  (bin content, error, x of center of bin)
    -2D : bc,e,xc,yc
    -3D : bc,e,xc,yc,zc

  Minimization function for H1s using a Likelihood method*-*-*-*-*-*
     Basically, it forms the likelihood by determining the Poisson
     probability that given a number of entries in a particular bin,
     the fit would predict it's value.  This is then done for each bin,
     and the sum of the logs is taken as the likelihood.
  The "I"ntegral method is used
  for each point the cache contains the following info
    -1D : bc,e,xc,xw  (bin content, error, x of center of bin, x bin width of bin)
    -2D : bc,e,xc,xw,yc,yw
    -3D : bc,e,xc,xw,yc,yw,zc,zw

  TF1 *fTFNF1;         //Pointer to theoretical function
void (*fFCN) (Int_t &, Double_t *, Double_t &f, Double_t *, Int_t);
  //wrapper function to calculate functional value, gradients and Z-matrix
  Double_t (*fTFN)(Double_t *, Double_t *, Double_t*); // Wrapper function for TFN