library: libHist
#include "TFormula.h"

TFormula


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

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 virtual Bool_t IsNormalized() 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:: kxgaus 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 static const enum TFormula:: kNormalized

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
*-*     -  gausn(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
*-*     gausn(0) is a substitute for [0]*exp(-0.5*((x-[1])/[2])**2)/(sqrt(2*pi)*[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     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
*-*
*-*   * 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]))
*-*
*-*   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)
*-*
*-*   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  (or gausn)
*-*    "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)
             Bool_t IsNormalized()
               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.81 2004/09/01 10:20:11 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *


ROOT page - Class index - Class Hierarchy - Top of the page

This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.