class TFormula: public TNamed

 Formula default constructor.

 Normal Formula constructor.

 Default constructor.

 Operator =

 Formula default destructor.

 Check if the chain as function call.

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

 Analyze a sub-expression in one formula.

   Expressions in one formula are recursively analyzed.
   Result of analysis is stored in the object tables.

                  Table of function codes and errors


   * functions :

     +           1                   pow          20
     -           2                   sq           21
     *           3                   sqrt         22
     /           4                   strstr       23
     %           5                   min          24
                                     max          25
                                     log          30
     cos         10                  exp          31
     sin         11                  log10        32
     tan         12
     acos        13                  abs          41
     asin        14                  sign         42
     atan        15                  int          43
     atan2       16
     fmod        17                  rndm         50

     cosh        70                  acosh        73
     sinh        71                  asinh        74
     tanh        72                  atanh        75

     expo       100                  gaus        110     gausn  (see note below)
     expo(0)    100 0                gaus(0)     110 0   gausn(0)
     expo(1)    100 1                gaus(1)     110 1   gausn(1)
     xexpo      100 x                xgaus       110 x   xgausn
     yexpo      101 x                ygaus       111 x   ygausn
     zexpo      102 x                zgaus       112 x   zgausn
     xyexpo     105 x                xygaus      115 x   xygausn
     yexpo(5)   102 5                ygaus(5)    111 5   ygausn(5)
     xyexpo(2)  105 2                xygaus(2)   115 2   xygausn(2)

     landau      120 x   landaun (see note below)
     landau(0)   120 0   landaun(0)
     landau(1)   120 1   landaun(1)
     xlandau     120 x   xlandaun
     ylandau     121 x   ylandaun
     zlandau     122 x   zlandaun
     xylandau    125 x   xylandaun
     ylandau(5)  121 5   ylandaun(5)
     xylandau(2) 125 2   xylandaun(2)

     pol0        130 x               pol1        130 1xx
     pol0(0)     130 0               pol1(0)     130 100
     pol0(1)     130 1               pol1(1)     130 101
     xpol0       130 x               xpol1       130 101
     ypol0       131 x               ypol1       131 101
     zpol0       132 x               zpol1       132 1xx
     ypol0(5)    131 5               ypol1(5)    131 105

     pi          40

     &&          60                  <            64
     ||          61                  >            65
     ==          62                  <=           66
     !=          63                  =>           67
     !           68
     ==(string)  76                  &            78
     !=(string)  77                  |            79
     <<(shift)   80                  >>(shift)    81
     ? :         82

   * constants (kConstants) :

    c0  141 1      c1  141 2  etc..

   * strings (kStringConst):

    sX  143 x

   * variables (kFormulaVar) :

     x    144 0      y    144 1      z    144 2      t    144 3

   * parameters :

     [1]        140 1
     [2]        140 2
     etc.

   Special cases for normalized gaussian or landau distributions

   the expression "gaus" is a substitute for
     [0]*exp(-0.5*((x-[1])/[2])**2)
   to obtain a standard normalized gaussian, use "gausn" instead of "gaus"
   the expression "gausn" is a substitute for
     [0]*exp(-0.5*((x-[1])/[2])**2)/(sqrt(2*pi)*[2]))
   WARNING: gaus and gausn are mutually exclusive in the same expression.

   In the same way the expression "landau" is a substitute for
     [0]*TMath::Landau(x,[1],[2],kFALSE)
   to obtain a standard normalized landau, use "landaun" instead of "landau"
   the expression "landaun" is a substitute for
     [0]*TMath::Landau(x,[1],[2],kTRUE)
   WARNING: landau and landaun are mutually exclusive in the same expression.

   Boolean optimization (kBoolOptmize) :


     Those pseudo operation are used to implement lazy evaluation of
     && and ||.  When the left hand of the expression if false
     (respectively true), the evaluation of the right is entirely skipped
     (since it would not change the value of the expreession).

     &&   142 11 (one operation on right) 142 21 (2 operations on right)
     ||   142 12 (one operation on right) 142 22 (2 operations on right)

   * functions calls (kFunctionCall) :

    f0 145  0  f1 145  1  etc..

   Errors :


     1  : Division By Zero
     2  : Invalid Floating Point Operation
     4  : Empty String
     5  : invalid syntax
     6  : Too many operators
     7  : Too many parameters
    10  : z specified but not x and y
    11  : z and y specified but not x
    12  : y specified but not x
    13  : z and x specified but not y
    20  : non integer value for parameter number
    21  : atan2 requires two arguments
    22  : pow requires two arguments
    23  : degree of polynomial not specified
    24  : Degree of polynomial must be positive
    25  : Degree of polynomial must be less than 20
    26  : Unknown name
    27  : Too many constants in expression
    28  : strstr requires two arguments
    29  : interpreted or compiled function have to return a numerical type
    30  : Bad numerical expression
    31  : Part of the variable exist but some of it is not accessible or useable
    40  : '(' is expected
    41  : ')' is expected
    42  : '[' is expected
    43  : ']' is expected

  Special functions

  By default, the formula is assigned fNumber=0. However, the following
  formula built with simple functions are assigned  fNumber:
    "gaus"      100  (or gausn)
    "xygaus"    110
    "expo"      200
    "polN"      300+N
    "landau"    400
    "xylandau"  410
  Note that expressions like gaus(0), expo(1) will force fNumber=0

  Warning when deriving a class from TFormula

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

 Check whether the operand at 'oper-1' is compatible with the operation
 at 'oper'.

 Check whether the operands at 'leftoper' and 'oper-1' are compatible with
 the operation at 'oper'.

 Try to 'demote' a string into an array bytes.  If this is not possible,
 return false.

 Resets the objects.

 Resets the object to its state before compilation.

 Resets the objects.

 Resets the object to its state before compilation.

 Compile expression already stored in fTitle.

   Loop on all subexpressions of formula stored in fTitle

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

 Copy this formula.

 Return address of string corresponding to special code.

   This member function is inactive in the TFormula class.
   It may be redefined in derived classes.

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

 Return value corresponding to special code.

   This member function is inactive in the TFormula class.
   It may be redefined in derived classes.

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

 Check if expression is in the list of defined variables.

   This member function can be overloaded in derived classes

   If you overload this member function, you also HAVE TO
   never call the constructor:

     TFormula::TFormula(const char *name,const char *expression)

   and write your own constructor

     MyClass::MyClass(const char *name,const char *expression) : TFormula()

   which has to call the TFormula default constructor and whose implementation
   should be similar to the implementation of the normal TFormula constructor

   This is necessary because the normal TFormula constructor call indirectly
   the virtual member functions Analyze, DefaultString, DefaultValue
   and DefaultVariable.

   The expected returns values are
     -2 :  the name has been recognized but won't be usable
     -1 :  the name has not been recognized
    >=0 :  the name has been recognized, return the action parameter.

 Evaluate this formula.

   The current value of variables x,y,z,t is passed through x, y, z and t.
   The parameters used will be the ones in the array params if params is given
    otherwise parameters will be taken from the stored data members fParams

 Evaluate this formula.

   The current value of variables x,y,z,t is passed through the pointer x.
   The parameters used will be the ones in the array params if params is given
    otherwise parameters will be taken from the stored data members fParams

 Reconstruct the formula expression from the internal TFormula member variables

   This function uses the internal member variables of TFormula to
   construct the mathematical expression associated with the TFormula
   instance. This function can be used to get an expanded version of the
   expression originally assigned to the TFormula instance, i.e. that
   the string returned by GetExpFormula() doesn't depend on other
   TFormula object names.

  if option contains "p" the returned string will contain the formula
  expression with symbolic parameters, eg [0] replaced by the actual value
  of the parameter. Example:
  if expression in formula is: "[0]*(x>-[1])+[2]*exp(-[3]*x)"
  and parameters are 3.25,-4.01,4.44,-0.04, GetExpFormula("p") will return:
   "(3.25*(x>+4.01))+(4.44*exp(+0.04*x))"

 Return linear part.

 Return value of parameter number ipar.

 Return value of parameter named parName.

 Return name of one parameter.

 Return parameter number by name.

 Return true if the expression at the index 'oper' has to be treated as a string

 Dump this formula with its attributes.

 If the formula is for linear fitting, change the title to
 normal and fill the LinearParts array

 Set the name of the formula. We need to allow the list of function to
 properly handle the hashes.

 Initialize parameter number ipar.

 Initialize parameter number ipar.

 Initialize array of all parameters.
 See also the next function with the same name.

 Initialize up to 11 parameters
 All arguments except THE FIRST TWO are optional
 In case of a function with only one parameter, call this function with p1=0.
 Minimum two arguments are required to differentiate this function
 from the SetParameters(cont Double_t *params)

 Set name of parameter number ipar

 Set up to 11 parameter names.

 Stream a class object.

 Convert the fOper of a TFormula version fromVersion to the current in memory version

  MakePrimitive
  find TFormulaPrimitive replacement for some operands

 MI include

 Optimize formula
 1.) Minimize the number of operands
     a.)  several operanands are glued togther
     b.)  some primitive functions glued together - exemp. (x+y) => PlusXY(x,y)
     c.)  maximize number of standard calls minimizing number of jumps in Eval cases
     d.)  variables, parameters and constants are mapped - using fOperOfssets0
          Eval procedure use direct acces to data (only one corresponding case statement in eval procedure)

          pdata[operand={Var,Par,Const}][offset]
          pdata[fOperOffsets0[i]][fOperOffset1[i+1]]
 2.) The fastest evaluation function is chosen at the end
     a.) fOptimal := pointer to the fastest function for given evaluation string
             switch(GetActionOptimized(0)){
               case kData : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive0; break;}
               case kUnary : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive1; break;}
               case kBinary : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive2; break;}
               case kThree : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive3; break;}
               case kFDM : {fOptimal= (TFormulaPrimitive::TFuncG)&TFormula::EvalPrimitive4; break;}
             }
     b.) ex. fOptimal = ::EvalPrimitive0 - if it return only variable, constant or parameter
                      = ::EvalParameter1 - if only one unary operation
                      = ::EvalPrimitive2 - if only one binary operation

 Evaluate primitive formula

 Evaluate primitive formula

 Evaluate primitive formula

 Evaluate primitive formula

 Evaluate primitive formula

 Evaluate primitive formula

 Evaluate this formula.

   The current value of variables x,y,z,t is passed through the pointer x.
   The parameters used will be the ones in the array params if params is given
    otherwise parameters will be taken from the stored data members fParams

 Pre compile function

 static function to set the maximum value of 3 parameters
  -maxop    : maximum number of operations
  -maxpar   : maximum number of parameters
  -maxconst : maximum number of constants
 None of these parameters cannot be less than 10 (default is 1000)
 call this function to increase one or all maxima when processing
 very complex formula, eg TFormula::SetMaxima(100000,1000,1000000);
 If you process many functions with a small number of operations/parameters
 you may gain some memory and performance by decreasing these values.

 static function to get the maximum value of 3 parameters
  -maxop    : maximum number of operations
  -maxpar   : maximum number of parameters
  -maxconst : maximum number of constants