library: libHist #include "TFormula.h"

# TFormula

class description - source file - inheritance tree (.ps)

## class TFormula : public TNamed

| Inheritance Chart:

`TObject`

<-

`TNamed`

<-

`TFormula`

<-

`TF1`

<-

`TF12` |

`TF2`

<-

`TF3` |

`TTreeFormula` |

        protected:

                    void ClearFormula(Option_t* option)
            virtual void Convert(UInt_t fromVersion)
                 Short_t GetAction(Int_t code) const
                   Int_t GetActionParam(Int_t code) const
                  Int_t* GetOper() const
          virtual Bool_t IsString(Int_t oper) const
                    void SetAction(Int_t code, Int_t value, Int_t param = 0)

        public:

                              TFormula()
                              TFormula(const char* name, const char* formula)
                              TFormula(const TFormula& formula)
                      virtual ~TFormula()
                 virtual void Analyze(const char* schain, Int_t& err, Int_t offset = 0)
               virtual Bool_t AnalyzeFunction(TString& chaine, Int_t& err, Int_t offset = 0)
               static TClass* Class()
                 virtual void Clear(Option_t* option)
                virtual Int_t Compile(const char* expression)
                 virtual void Copy(TObject& formula) const
                virtual char* DefinedString(Int_t code)
             virtual Double_t DefinedValue(Int_t code)
                virtual Int_t DefinedVariable(TString& variable, Int_t& action)
             virtual Double_t Eval(Double_t x, Double_t y = 0, Double_t z = 0, Double_t t = 0)
             virtual Double_t EvalPar(const Double_t* x, const Double_t* params = 0)
              virtual TString GetExpFormula() const
                virtual Int_t GetNdim() const
                virtual Int_t GetNpar() const
                virtual Int_t GetNumber() const
                     Double_t GetParameter(Int_t ipar) const
                     Double_t GetParameter(const char* name) const
            virtual Double_t* GetParameters() const
                 virtual void GetParameters(Double_t* params)
          virtual const char* GetParName(Int_t ipar) const
                virtual Int_t GetParNumber(const char* name) const
              virtual TClass* IsA() const
                    TFormula& operator=(const TFormula& rhs)
                 virtual void Print(Option_t* option) const
                 virtual void SetNumber(Int_t number)
                 virtual void SetParameter(const char* name, Double_t parvalue)
                 virtual void SetParameter(Int_t ipar, Double_t parvalue)
                 virtual void SetParameters(const Double_t* params)
                 virtual void SetParameters(Double_t p0, Double_t p1, Double_t p2 = 0, Double_t p3 = 0, Double_t p4 = 0, Double_t p5 = 0, Double_t p6 = 0, Double_t p7 = 0, Double_t p8 = 0, Double_t p9 = 0, Double_t p10 = 0)
                 virtual void SetParName(Int_t ipar, const char* name)
                 virtual void SetParNames(const char* name0 = "p0", const char* name1 = "p1", const char* name2 = "p2", const char* name3 = "p3", const char* name4 = "p4", const char* name5 = "p5", const char* name6 = "p6", const char* name7 = "p7", const char* name8 = "p8", const char* name9 = "p9", const char* name10 = "p10")
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void StreamerNVirtual(TBuffer& b)
                 virtual void Update()

### Data Members

        private:

          Int_t* fOper  [fNoper] List of operators. (See documentation for changes made at version 7)

        protected:

              Int_t fNdim          Dimension of function (1=1-Dim, 2=2-Dim,etc)
              Int_t fNpar          Number of parameters
              Int_t fNoper         Number of operators
              Int_t fNconst        Number of constants
              Int_t fNumber        formula number identifier
              Int_t fNval          Number of different variables in expression
              Int_t fNstring       Number of different constants character strings
           TString* fExpr          [fNoper] List of expressions
          Double_t* fConst         [fNconst] Array of fNconst formula constants
          Double_t* fParams        [fNpar] Array of fNpar parameters
           TString* fNames         [fNpar] Array of parameter names
          TObjArray fFunctions     Array of function calls to make
              TBits fAlreadyFound  ! cache for information

        public:

          static const enum TFormula:: kEnd
          static const enum TFormula:: kAdd
          static const enum TFormula:: kSubstract
          static const enum TFormula:: kMultiply
          static const enum TFormula:: kDivide
          static const enum TFormula:: kModulo
          static const enum TFormula:: kcos
          static const enum TFormula:: ksin
          static const enum TFormula:: ktan
          static const enum TFormula:: kacos
          static const enum TFormula:: kasin
          static const enum TFormula:: katan
          static const enum TFormula:: katan2
          static const enum TFormula:: kfmod
          static const enum TFormula:: kpow
          static const enum TFormula:: ksq
          static const enum TFormula:: ksqrt
          static const enum TFormula:: kstrstr
          static const enum TFormula:: kmin
          static const enum TFormula:: kmax
          static const enum TFormula:: klog
          static const enum TFormula:: kexp
          static const enum TFormula:: klog10
          static const enum TFormula:: kpi
          static const enum TFormula:: kabs
          static const enum TFormula:: ksign
          static const enum TFormula:: kint
          static const enum TFormula:: kSignInv
          static const enum TFormula:: krndm
          static const enum TFormula:: kAnd
          static const enum TFormula:: kOr
          static const enum TFormula:: kEqual
          static const enum TFormula:: kNotEqual
          static const enum TFormula:: kLess
          static const enum TFormula:: kGreater
          static const enum TFormula:: kLessThan
          static const enum TFormula:: kGreaterThan
          static const enum TFormula:: kNot
          static const enum TFormula:: kcosh
          static const enum TFormula:: ksinh
          static const enum TFormula:: ktanh
          static const enum TFormula:: kacosh
          static const enum TFormula:: kasinh
          static const enum TFormula:: katanh
          static const enum TFormula:: kStringEqual
          static const enum TFormula:: kStringNotEqual
          static const enum TFormula:: kBitAnd
          static const enum TFormula:: kBitOr
          static const enum TFormula:: kLeftShift
          static const enum TFormula:: kRightShift
          static const enum TFormula:: kexpo
          static const enum TFormula:: kxexpo
          static const enum TFormula:: kyexpo
          static const enum TFormula:: kzexpo
          static const enum TFormula:: kxyexpo
          static const enum TFormula:: kgaus
          static const enum TFormula:: kxgaux
          static const enum TFormula:: kygaus
          static const enum TFormula:: kzgaus
          static const enum TFormula:: kxygaus
          static const enum TFormula:: klandau
          static const enum TFormula:: kxlandau
          static const enum TFormula:: kylandau
          static const enum TFormula:: kzlandau
          static const enum TFormula:: kxylandau
          static const enum TFormula:: kpol
          static const enum TFormula:: kxpol
          static const enum TFormula:: kypol
          static const enum TFormula:: kzpol
          static const enum TFormula:: kParameter
          static const enum TFormula:: kConstant
          static const enum TFormula:: kBoolOptimize
          static const enum TFormula:: kStringConst
          static const enum TFormula:: kVariable
          static const enum TFormula:: kFunctionCall
          static const enum TFormula:: kDefinedVariable
          static const enum TFormula:: kDefinedString
          static const enum TFormula:: kNotGlobal
          static const enum TFormula:: kInitialized

## Class Description

    *-*-*-*-*-*-*-*-*-*-*The  F O R M U L A  class*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                  =========================
    *-*
    *-*   This class has been implemented by

Nicolas Brun

    (age 18).
    *-*   ========================================================

/* */

    *-*
    *-*  Example of valid expressions:
    *-*     -  sin(x)/x
    *-*     -  [0]*sin(x) + [1]*exp(-[2]*x)
    *-*     -  x + y**2
    *-*     -  x^2 + y^2
    *-*     -  [0]*pow([1],4)
    *-*     -  2*pi*sqrt(x/y)
    *-*     -  gaus(0)*expo(3) + ypol3(5)*x
    *-*
    *-*  In the last example above:
    *-*     gaus(0) is a substitute for [0]*exp(-0.5*((x-[1])/[2])**2)
    *-*        and (0) means start numbering parameters at 0
    *-*     expo(3) is a substitute for exp([3]+[4])*x)
    *-*     pol3(5) is a substitute for par[5]+par[6]*x+par[7]*x**2+par[8]*x**3
    *-*         (here Pol3 stands for Polynomial of degree 3)
    *-*
    *-*   TMath functions can be part of the expression, eg:
    *-*     -  TMath::Landau(x)*sin(x)
    *-*     -  TMath::Erf(x)
    *-*
    *-*   Comparisons operators are also supported (&&, ||, ==, <=, >=, !)
    *-*   Examples:
    *-*      sin(x*(x<0.5 || x>1))
    *-*   If the result of a comparison is TRUE, the result is 1, otherwise 0.
    *-*
    *-*   Already predefined names can be given. For example, if the formula
    *-*     TFormula old(sin(x*(x<0.5 || x>1))) one can assign a name to the formula. By default
    *-*     the name of the object = title = formula itself.
    *-*     old.SetName("old").
    *-*     then, old can be reused in a new expression.
    *-*     TFormula new("x*old") is equivalent to:
    *-*     TFormula new("x*sin(x*(x<0.5 || x>1))")
    *-*
    *-*   Up to 4 dimensions are supported (indicated by x, y, z, t)
    *-*   An expression may have 0 parameters or a list of parameters
    *-*   indicated by the sequence [par_number]
    *-*
    *-*   A graph showing the logic to compile and analyze a formula
    *-*   is shown in TFormula::Compile and TFormula::Analyze.
    *-*   Once a formula has been compiled, it can be evaluated for a given
    *-*   set of parameters. see graph in TFormula::EvalPar.
    *-*
    *-*   This class is the base class for the function classes TF1,TF2 and TF3.
    *-*   It is also used by the ntuple selection mechanism TNtupleFormula.
    *-*
    *-*   In version 7 of TFormula, the usage of fOper has been changed
    *-*   to improve the performance of TFormula::EvalPar.
    *-*   Conceptually, fOper was changed from a simple array of Int_t
    *-*   to an array of composite values.
    *-*   For example a 'ylandau(5)' operation used to be encoded as 4105;
    *-*   it is now encoded as (klandau >> kTFOperShit) + 5
    *-*   Any class inheriting from TFormula and using directly fOper (which
    *-*   is now a private data member), needs to be updated to take this
    *-*   in consideration.  The member functions recommended to set and
    *-*   access fOper are:  SetAction, GetAction, GetActionParam
    *-*   For more performant access to the information, see the implementation
    *-*   TFormula::EvalPar
    *-*
    *-*     WHY TFormula CANNOT ACCEPT A CLASS MEMBER FUNCTION ?
    *-*     ====================================================
    *-* This is a frequently asked question.
    *-* C++ is a strongly typed language. There is no way for TFormula (without
    *-* recompiling this class) to know about all possible user defined data types.
    *-* This also apply to the case of a static class function.
    *-* Because TMath is a special and frequent case, TFormula is aware
    *-* of all TMath functions.
    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

TFormula(): TNamed()

    *-*-*-*-*-*-*-*-*-*-*Formula default constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                  ============================

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

    *-*-*-*-*-*-*-*-*-*-*Normal Formula constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                  ==========================

TFormula(const TFormula &formula) : TNamed()

~TFormula()

    *-*-*-*-*-*-*-*-*-*-*Formula default destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                  ===========================

Bool_t AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset)

    *-*-*-*-*-*-*-*-*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.
    *-*

void Analyze(const char *schain, Int_t &err, Int_t offset)

    *-*-*-*-*-*-*-*-*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
    *-*     expo(0)    100 0                gaus(0)     110 0
    *-*     expo(1)    100 1                gaus(1)     110 1
    *-*     xexpo      100 x                xgaus       110 x
    *-*     yexpo      101 x                ygaus       111 x
    *-*     zexpo      102 x                zgaus       112 x
    *-*     xyexpo     105 x                xygaus      115 x
    *-*     yexpo(5)   102 5                ygaus(5)    111 5
    *-*     xyexpo(2)  105 2                xygaus(2)   115 2
    *-*
    *-*     landau      120 x
    *-*     landau(0)   120 0
    *-*     landau(1)   120 1
    *-*     xlandau     120 x
    *-*     ylandau     121 x
    *-*     zlandau     122 x
    *-*     xylandau    125 x
    *-*     ylandau(5)  121 5
    *-*     xylandau(2) 125 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
    *-*
    *-*   * 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.
    *-*
    *-*   * 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  : Variable exist but is not accessible
    *-*    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
    *-*    "expo"    200
    *-*    "polN"    300+N
    *-*    "landau"  400
    *-*  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.
    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

void Clear(Option_t * /*option*/ )

    *-*-*-*-*-*-*-*-*Resets the objects*-*-*-*-*-*-*-*-*-*-*
    *-*              ==================
    *-*
    *-* Resets the object to its state before compilation.
    *-*

void ClearFormula(Option_t * /*option*/ )

    *-*-*-*-*-*-*-*-*Resets the objects*-*-*-*-*-*-*-*-*-*-*
    *-*              ==================
    *-*
    *-* Resets the object to its state before compilation.
    *-*

Int_t Compile(const char *expression)

    *-*-*-*-*-*-*-*-*-*-*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.
    *-*

/* */

    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

void Copy(TObject &obj) const

    *-*-*-*-*-*-*-*-*-*-*Copy this formula*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                  =================

char* DefinedString(Int_t)

    *-*-*-*-*-*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.
    *-*
    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Double_t DefinedValue(Int_t)

    *-*-*-*-*-*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.
    *-*
    /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Int_t DefinedVariable(TString &chaine,Int_t &action)

    *-*-*-*-*-*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.
    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Double_t Eval(Double_t x, Double_t y, Double_t z, Double_t t)

    *-*-*-*-*-*-*-*-*-*-*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
    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Double_t EvalPar(const Double_t *x, const Double_t *params)

    *-*-*-*-*-*-*-*-*-*-*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

/* */

    *-*
    *-*
    *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

TString GetExpFormula() const

    *-*-*-*-*-*-*-*-*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

Double_t GetParameter(Int_t ipar) const

    return value of parameter number ipar

Double_t GetParameter(const char *parName) const

    return value of parameter named parName

const char* GetParName(Int_t ipar) const

    *-*-*-*-*-*-*-*Return name of one parameter*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*            ============================

Int_t GetParNumber(const char *parName) const

     return parameter number by name

Bool_t IsString(Int_t oper) const

     return true if the expression at the index 'oper' is to be treated as
     as string

void Print(Option_t *) const

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

void SetParameter(const char *name, Double_t value)

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

void SetParameter(Int_t ipar, Double_t value)

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

void SetParameters(const Double_t *params)

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

void SetParameters(Double_t p0,Double_t p1,Double_t p2,Double_t p3,Double_t p4 ,Double_t p5,Double_t p6,Double_t p7,Double_t p8,Double_t p9,Double_t p10)

     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)

void SetParName(Int_t ipar, const char *name)

     Set name of parameter number ipar

void SetParNames(const char*name0,const char*name1,const char*name2,const char*name3,const char*name4, const char*name5,const char*name6,const char*name7,const char*name8,const char*name9,const char*name10)

    *-*-*-*-*-*-*-*-*-*Set up to 10 parameter names*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*                ============================

void Streamer(TBuffer &b)

    *-*-*-*-*-*-*-*-*Stream a class object*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
    *-*              =========================================

void Convert(UInt_t /* fromVersion */)

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

### Inline Functions

                 Int_t* GetOper() const
                Short_t GetAction(Int_t code) const
                  Int_t GetActionParam(Int_t code) const
                   void SetAction(Int_t code, Int_t value, Int_t param = 0)
              TFormula& operator=(const TFormula& rhs)
                  Int_t GetNdim() const
                  Int_t GetNpar() const
                  Int_t GetNumber() const
              Double_t* GetParameters() const
                   void GetParameters(Double_t* params)
                   void SetNumber(Int_t number)
                   void Update()
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void StreamerNVirtual(TBuffer& b)

Author: Nicolas Brun 19/08/95
Last update: root/hist:$Name: $:$Id: TFormula.cxx,v 1.77 2004/05/12 22:43:06 rdm Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *