library: libHist
#include "TFormula.h" |
TFormula
class description - source file - inheritance tree (.pdf)
protected:
void ClearFormula(Option_t* option = "")
virtual void Convert(UInt_t fromVersion)
Double_t EvalParFast(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive0(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive1(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive2(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive3(const Double_t* x, const Double_t* params)
Double_t EvalPrimitive4(const Double_t* x, const Double_t* params)
Short_t GetAction(Int_t code) const
Short_t GetActionOptimized(Int_t code) const
Int_t GetActionParam(Int_t code) const
Int_t GetActionParamOptimized(Int_t code) const
Int_t* GetOper() const
Int_t* GetOperOptimized() const
virtual Bool_t IsString(Int_t oper) const
void MakePrimitive(const char* expr, Int_t pos)
Int_t PreCompile()
void SetAction(Int_t code, Int_t value, Int_t param = 0)
void SetActionOptimized(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) const
virtual Double_t EvalPar(const Double_t* x, const Double_t* params = 0)
virtual Double_t EvalParOld(const Double_t* x, const Double_t* params = 0)
virtual TString GetExpFormula() const
virtual const TObject* GetLinearPart(Int_t i) 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 IsLinear()
virtual Bool_t IsNormalized()
TFormula& operator=(const TFormula& rhs)
void Optimize()
virtual void Print(Option_t* option = "") const
virtual void ProcessLinear(TString& replaceformula)
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()
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
TObjArray fLinearParts ! Linear parts if the formula is linear (contains '|')
TBits fAlreadyFound ! cache for information
Int_t fNOperOptimized !Number of operators after optimization
TString* fExprOptimized ![fNOperOptimized] List of expressions
Int_t* fOperOptimized ![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
TOperOffset* fOperOffset ![fNOperOptimized] Offsets of operrands
TFormulaPrimitive** fPredefined ![fNPar] predefined function
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:: kData
static const enum TFormula:: kUnary
static const enum TFormula:: kBinary
static const enum TFormula:: kThree
static const enum TFormula:: kDefinedVariable
static const enum TFormula:: kDefinedString
static const enum TFormula:: kPlusD
static const enum TFormula:: kPlusDD
static const enum TFormula:: kMultD
static const enum TFormula:: kMultDD
static const enum TFormula:: kBoolOptimizeOr
static const enum TFormula:: kBoolOptimizeAnd
static const enum TFormula:: kBoolSet
static const enum TFormula:: kFDM
static const enum TFormula:: kFD0
static const enum TFormula:: kFD1
static const enum TFormula:: kFD2
static const enum TFormula:: kFD3
static const enum TFormula:: kNotGlobal
static const enum TFormula:: kNormalized
static const enum TFormula:: kLinear
G__p2memfunc fOptimal !pointer to optimal function
*-*-*-*-*-*-*-*-*-*-*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 : 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)
*-* "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) const
*-*-*-*-*-*-*-*-*-*-*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 EvalParOld(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
const TObject* GetLinearPart(Int_t i)
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 ProcessLinear(TString &formula)
if the formula is for linear fitting, change the title to
normal and fill the LinearParts array
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
void MakePrimitive(const char *expr, Int_t pos)
MakePrimitive
find TFormulaPrimitive replacement for some operands
void Optimize()
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
.......
Double_t EvalPrimitive(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalPrimitive0(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalPrimitive1(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalPrimitive2(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalPrimitive3(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalPrimitive4(const Double_t *x, const Double_t *params)
Evaluate primitive formula
Double_t EvalParFast(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
/*
*/
*-*
*-*
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Int_t PreCompile()
Pre compile function
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)
Int_t* GetOperOptimized() const
Short_t GetActionOptimized(Int_t code) const
Int_t GetActionParamOptimized(Int_t code) const
void SetActionOptimized(Int_t code, Int_t value, Int_t param = 0)
TFormula& operator=(const TFormula& rhs)
Double_t EvalPar(const Double_t* x, const Double_t* params = 0)
Int_t GetNdim() const
Int_t GetNpar() const
Int_t GetNumber() const
Double_t* GetParameters() const
void GetParameters(Double_t* params)
Bool_t IsLinear()
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.103 2005/09/05 10:13:27 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.