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' is to be treated as
 as string

-*Dump this formula with its attributes
*-*                  =====================================

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

Initialize parameter number ipar*-*-*-*-*-
*-*            ================================

Initialize parameter number ipar*-*-*-*-*-
*-*            ================================

 Initialize array of all parameters
 see also next function with same name

 Initialize up to 10 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 10 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 choosen 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.