Logo ROOT  
Reference Guide
TFormula.h
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Nicolas Brun 19/08/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11// ---------------------------------- Formula.h
12
13#ifndef ROOT_v5_TFormula
14#define ROOT_v5_TFormula
15
16
17
18//////////////////////////////////////////////////////////////////////////
19// //
20// TFormula //
21// //
22// The old formula base class f(x,y,z,par) //
23// mantained for backward compatibility and TTree usage //
24//////////////////////////////////////////////////////////////////////////
25
26#include "TNamed.h"
27#include "TBits.h"
28#include "TObjArray.h"
31const Int_t kMAXFOUND = 500;
32const Int_t kTFOperMask = 0x7fffff;
37namespace ROOT {
38 namespace v5 {
40 class TFormulaPrimitive;
43 friend class TFormula;
44public:
45 enum {
48 kConstant = 2
49 };
51protected:
52 Short_t fType0; // type of operand 0
53 Short_t fOffset0; // offset of operand 0
54 Short_t fType1; // type of operand 1
55 Short_t fOffset1; // offset of operand 1
56 Short_t fType2; // type of operand 2
57 Short_t fOffset2; // offset of operand 2
58 Short_t fType3; // type of operand 3
59 Short_t fOffset3; // offset of operand 3
60 Short_t fToJump; // where to jump in case of optimized boolen
61 Short_t fOldAction; // temporary variable used during optimization
62};
65class TFormula : public TNamed {
67protected:
69 typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
71 Int_t fNdim; //Dimension of function (1=1-Dim, 2=2-Dim,etc)
72 Int_t fNpar; //Number of parameters
73 Int_t fNoper; //Number of operators
74 Int_t fNconst; //Number of constants
75 Int_t fNumber; //formula number identifier
76 Int_t fNval; //Number of different variables in expression
77 Int_t fNstring; //Number of different constants character strings
78 TString *fExpr; //[fNoper] List of expressions
79private:
80 Int_t *fOper; //[fNoper] List of operators. (See documentation for changes made at version 7)
81protected:
82 Double_t *fConst; //[fNconst] Array of fNconst formula constants
83 Double_t *fParams; //[fNpar] Array of fNpar parameters
84 TString *fNames; //[fNpar] Array of parameter names
85 TObjArray fFunctions; //Array of function calls to make
86 TObjArray fLinearParts; //Linear parts if the formula is linear (contains '|' or "++")
87
88 TBits fAlreadyFound; //! cache for information
90 // Optimized expression
91 Int_t fNOperOptimized; //!Number of operators after optimization
92 TString *fExprOptimized; //![fNOperOptimized] List of expressions
93 Int_t *fOperOptimized; //![fNOperOptimized] List of operators. (See documentation for changes made at version 7)
94 TOperOffset *fOperOffset; //![fNOperOptimized] Offsets of operrands
95 TFormulaPrimitive **fPredefined; //![fNPar] predefined function
96 TFuncG fOptimal; //!pointer to optimal function
99 virtual Bool_t CheckOperands(Int_t operation, Int_t &err);
100 virtual Bool_t CheckOperands(Int_t leftoperand, Int_t rightoperartion, Int_t &err);
102 void MakePrimitive(const char *expr, Int_t pos);
103 inline Int_t *GetOper() const { return fOper; }
104 inline Short_t GetAction(Int_t code) const { return fOper[code] >> kTFOperShift; }
105 inline Int_t GetActionParam(Int_t code) const { return fOper[code] & kTFOperMask; }
107 inline void SetAction(Int_t code, Int_t value, Int_t param = 0) {
108 fOper[code] = (value) << kTFOperShift;
109 fOper[code] += param;
110 }
111 inline Int_t *GetOperOptimized() const { return fOperOptimized; }
112 inline Short_t GetActionOptimized(Int_t code) const { return fOperOptimized[code] >> kTFOperShift; }
113 inline Int_t GetActionParamOptimized(Int_t code) const { return fOperOptimized[code] & kTFOperMask; }
115 inline void SetActionOptimized(Int_t code, Int_t value, Int_t param = 0) {
116 fOperOptimized[code] = (value) << kTFOperShift;
117 fOperOptimized[code] += param;
118 }
119
120 void ClearFormula(Option_t *option="");
121 virtual Bool_t IsString(Int_t oper) const;
123 virtual void Convert(UInt_t fromVersion);
124 //
125 // Functions - used for formula evaluation
126 Double_t EvalParFast(const Double_t *x, const Double_t *params);
127 Double_t EvalPrimitive(const Double_t *x, const Double_t *params);
128 Double_t EvalPrimitive0(const Double_t *x, const Double_t *params);
129 Double_t EvalPrimitive1(const Double_t *x, const Double_t *params);
130 Double_t EvalPrimitive2(const Double_t *x, const Double_t *params);
131 Double_t EvalPrimitive3(const Double_t *x, const Double_t *params);
132 Double_t EvalPrimitive4(const Double_t *x, const Double_t *params);
134 // Action code for Version 6 and above.
135 enum {
136 kEnd = 0,
137 kAdd = 1, kSubstract = 2,
141 kcos = 10, ksin = 11 , ktan = 12,
142 kacos = 13, kasin = 14 , katan = 15,
143 katan2 = 16,
144 kfmod = 17,
145
146 kpow = 20, ksq = 21, ksqrt = 22,
147
149
150 kmin = 24, kmax = 25,
151
152 klog = 30, kexp = 31, klog10 = 32,
154 kpi = 40,
156 kabs = 41 , ksign= 42,
157 kint = 43 ,
159 krndm = 50 ,
160
161 kAnd = 60, kOr = 61,
162 kEqual = 62, kNotEqual = 63,
163 kLess = 64, kGreater = 65,
165 kNot = 68,
166
167 kcosh = 70 , ksinh = 71, ktanh = 72,
168 kacosh = 73 , kasinh = 74, katanh = 75,
172 kBitAnd = 78, kBitOr = 79,
175 kJumpIf = 82, kJump = 83,
176
177 kexpo = 100 , kxexpo = 100, kyexpo = 101, kzexpo = 102, kxyexpo = 105,
178 kgaus = 110 , kxgaus = 110, kygaus = 111, kzgaus = 112, kxygaus = 115,
179 klandau = 120 , kxlandau = 120, kylandau = 121, kzlandau = 122, kxylandau = 125,
180 kpol = 130 , kxpol = 130, kypol = 131, kzpol = 132,
181
188 kData = 146,
189 kUnary = 147,
190 kBinary = 148,
191 kThree = 149,
194 //
195 kPlusD = 152,
196 kPlusDD = 153,
197 kMultD = 154,
198 kMultDD = 155,
201 kBoolSet = 158,
202 kFDM = 159,
203 kFD0 = 160,
204 kFD1 = 161,
205 kFD2 = 162,
206 kFD3 = 163
207 };
208
209public:
210 // TFormula status bits
211 enum {
212 kNotGlobal = BIT(10), // don't store in gROOT->GetListOfFunction
213 kNormalized = BIT(14), // set to true if the function (ex gausn) is normalized
214 kLinear = BIT(16) //set to true if the function is for linear fitting
215 };
216
217 TFormula();
218 TFormula(const char *name,const char *formula);
219 TFormula(const TFormula &formula);
221 virtual ~TFormula();
223 public:
224 void Optimize();
225 virtual void Analyze(const char *schain, Int_t &err, Int_t offset=0);
226 virtual Bool_t AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset=0);
227 virtual Int_t Compile(const char *expression="");
228 virtual void Copy(TObject &formula) const;
229 virtual void Clear(Option_t *option="");
230 virtual char *DefinedString(Int_t code);
232 virtual Int_t DefinedVariable(TString &variable,Int_t &action);
233 virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const;
234 virtual Double_t EvalParOld(const Double_t *x, const Double_t *params=0);
235 virtual Double_t EvalPar(const Double_t *x, const Double_t *params=0){return ((*this).*fOptimal)(x,params);};
236 virtual const TObject *GetLinearPart(Int_t i);
237 virtual Int_t GetNdim() const {return fNdim;}
238 virtual Int_t GetNpar() const {return fNpar;}
239 virtual Int_t GetNumber() const {return fNumber;}
240 virtual TString GetExpFormula(Option_t *option="") const;
241 Double_t GetParameter(Int_t ipar) const;
242 Double_t GetParameter(const char *name) const;
243 virtual Double_t *GetParameters() const {return fParams;}
244 virtual void GetParameters(Double_t *params){for(Int_t i=0;i<fNpar;i++) params[i] = fParams[i];}
245 virtual const char *GetParName(Int_t ipar) const;
246 virtual Int_t GetParNumber(const char *name) const;
247 virtual Bool_t IsLinear() const {return TestBit(kLinear);}
248 virtual Bool_t IsNormalized() const {return TestBit(kNormalized);}
249 virtual void Print(Option_t *option="") const; // *MENU*
250 virtual void ProcessLinear(TString &replaceformula);
251 virtual void SetNumber(Int_t number) {fNumber = number;}
252 virtual void SetParameter(const char *name, Double_t parvalue);
253 virtual void SetParameter(Int_t ipar, Double_t parvalue);
254 virtual void SetParameters(const Double_t *params);
255 virtual void SetParameters(Double_t p0,Double_t p1,Double_t p2=0,Double_t p3=0,Double_t p4=0,
256 Double_t p5=0,Double_t p6=0,Double_t p7=0,Double_t p8=0,
257 Double_t p9=0,Double_t p10=0); // *MENU*
258 virtual void SetParName(Int_t ipar, const char *name);
259 virtual void SetParNames(const char *name0="p0",const char *name1="p1",const char
260 *name2="p2",const char *name3="p3",const char
261 *name4="p4", const char *name5="p5",const char *name6="p6",const char *name7="p7",const char
262 *name8="p8",const char *name9="p9",const char *name10="p10"); // *MENU*
263 virtual void Update() {;}
264
265 static void SetMaxima(Int_t maxop=1000, Int_t maxpar=1000, Int_t maxconst=1000);
266 static void GetMaxima(Int_t& maxop, Int_t& maxpar, Int_t& maxconst);
267
268 void Streamer(TBuffer &b, const TClass *onfile_class);
269 void Streamer(TBuffer &b, Int_t version, UInt_t start, UInt_t count, const TClass *onfile_class = 0);
270
271 ClassDef(ROOT::v5::TFormula,8) //The formula base class f(x,y,z,par)
272};
273
274 } // end namespace v5
275
276} // end namespace ROOT
277
278#endif
#define b(i)
Definition: RSha256.hxx:100
int Int_t
Definition: RtypesCore.h:43
unsigned char UChar_t
Definition: RtypesCore.h:36
unsigned int UInt_t
Definition: RtypesCore.h:44
bool Bool_t
Definition: RtypesCore.h:61
short Short_t
Definition: RtypesCore.h:37
double Double_t
Definition: RtypesCore.h:57
const char Option_t
Definition: RtypesCore.h:64
#define ClassDef(name, id)
Definition: Rtypes.h:322
#define BIT(n)
Definition: Rtypes.h:83
char name[80]
Definition: TGX11.cxx:109
The FORMULA class (ROOT version 5)
Definition: TFormula.h:65
Double_t * fConst
Definition: TFormula.h:82
virtual Int_t GetNumber() const
Definition: TFormula.h:239
virtual Bool_t StringToNumber(Int_t code)
Try to 'demote' a string into an array bytes.
Double_t GetParameter(Int_t ipar) const
Return value of parameter number ipar.
TString * fExprOptimized
Number of operators after optimization.
Definition: TFormula.h:92
virtual ~TFormula()
Formula default destructor.
virtual Bool_t IsNormalized() const
Definition: TFormula.h:248
virtual Double_t * GetParameters() const
Definition: TFormula.h:243
virtual Double_t EvalPar(const Double_t *x, const Double_t *params=0)
Definition: TFormula.h:235
virtual Double_t DefinedValue(Int_t code)
Return value corresponding to special code.
virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const
Evaluate this formula.
TObjArray fFunctions
Definition: TFormula.h:85
virtual Int_t GetParNumber(const char *name) const
Return parameter number by name.
virtual void Convert(UInt_t fromVersion)
void SetActionOptimized(Int_t code, Int_t value, Int_t param=0)
Definition: TFormula.h:115
Double_t EvalPrimitive1(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
Int_t * GetOper() const
Definition: TFormula.h:103
virtual void SetParName(Int_t ipar, const char *name)
Set name of parameter number ipar.
virtual void SetParameter(const char *name, Double_t parvalue)
Initialize parameter number ipar.
Double_t EvalPrimitive0(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
virtual Bool_t IsLinear() const
Definition: TFormula.h:247
virtual void Update()
Definition: TFormula.h:263
virtual Bool_t AnalyzeFunction(TString &chaine, Int_t &err, Int_t offset=0)
Check if the chain as function call.
TFormula()
Formula default constructor.
Double_t EvalPrimitive2(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
TString * fExpr
Definition: TFormula.h:78
virtual Double_t EvalParOld(const Double_t *x, const Double_t *params=0)
Evaluate this formula.
TObjArray fLinearParts
Definition: TFormula.h:86
void ClearFormula(Option_t *option="")
Resets the objects.
virtual const char * GetParName(Int_t ipar) const
Return name of one parameter.
virtual void SetNumber(Int_t number)
Definition: TFormula.h:251
TOperOffset * fOperOffset
[fNOperOptimized] List of operators. (See documentation for changes made at version 7)
Definition: TFormula.h:94
virtual char * DefinedString(Int_t code)
Return address of string corresponding to special code.
void Optimize()
MI include.
Double_t EvalParFast(const Double_t *x, const Double_t *params)
Evaluate this formula.
virtual void SetParameters(const Double_t *params)
Initialize array of all parameters.
virtual Int_t GetNdim() const
Definition: TFormula.h:237
Short_t GetAction(Int_t code) const
Definition: TFormula.h:104
static void SetMaxima(Int_t maxop=1000, Int_t maxpar=1000, Int_t maxconst=1000)
static function to set the maximum value of 3 parameters
virtual void Print(Option_t *option="") const
Dump this formula with its attributes.
virtual const TObject * GetLinearPart(Int_t i)
Return linear part.
Int_t fNOperOptimized
cache for information
Definition: TFormula.h:91
virtual void ProcessLinear(TString &replaceformula)
If the formula is for linear fitting, change the title to normal and fill the LinearParts array.
Short_t GetActionOptimized(Int_t code) const
Definition: TFormula.h:112
virtual Bool_t CheckOperands(Int_t operation, Int_t &err)
Check whether the operand at 'oper-1' is compatible with the operation at 'oper'.
Double_t EvalPrimitive3(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
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")
Set up to 11 parameter names.
Int_t * fOperOptimized
[fNOperOptimized] List of expressions
Definition: TFormula.h:93
virtual void GetParameters(Double_t *params)
Definition: TFormula.h:244
virtual Int_t GetNpar() const
Definition: TFormula.h:238
virtual Int_t DefinedVariable(TString &variable, Int_t &action)
Check if expression is in the list of defined variables.
Int_t GetActionParam(Int_t code) const
Definition: TFormula.h:105
TFuncG fOptimal
[fNPar] predefined function
Definition: TFormula.h:96
TBits fAlreadyFound
Definition: TFormula.h:88
Double_t EvalPrimitive4(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
virtual void Analyze(const char *schain, Int_t &err, Int_t offset=0)
Analyze a sub-expression in one formula.
virtual TString GetExpFormula(Option_t *option="") const
Reconstruct the formula expression from the internal TFormula member variables.
void MakePrimitive(const char *expr, Int_t pos)
MakePrimitive find TFormulaPrimitive replacement for some operands.
Int_t GetActionParamOptimized(Int_t code) const
Definition: TFormula.h:113
static void GetMaxima(Int_t &maxop, Int_t &maxpar, Int_t &maxconst)
static function to get the maximum value of 3 parameters -maxop : maximum number of operations -maxpa...
TFormulaPrimitive ** fPredefined
[fNOperOptimized] Offsets of operrands
Definition: TFormula.h:95
TFormula & operator=(const TFormula &rhs)
Operator =.
virtual Int_t Compile(const char *expression="")
Compile expression already stored in fTitle.
Int_t * GetOperOptimized() const
Definition: TFormula.h:111
void SetAction(Int_t code, Int_t value, Int_t param=0)
Definition: TFormula.h:107
virtual void Copy(TObject &formula) const
Copy this formula.
Double_t(TObject::* TFuncG)(const Double_t *, const Double_t *) const
Definition: TFormula.h:69
Double_t EvalPrimitive(const Double_t *x, const Double_t *params)
Evaluate primitive formula.
virtual void Clear(Option_t *option="")
Resets the objects.
Double_t * fParams
Definition: TFormula.h:83
void Streamer(TBuffer &b, const TClass *onfile_class)
Stream a class object.
TString * fNames
Definition: TFormula.h:84
virtual Bool_t IsString(Int_t oper) const
Return true if the expression at the index 'oper' has to be treated as a string.
Int_t PreCompile()
pointer to optimal function
TOperOffset()
TOper offset - helper class for TFormula* specify type of operand fTypeX = kVariable = kParameter = k...
Container of bits.
Definition: TBits.h:27
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
The Formula class.
Definition: TFormula.h:84
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:29
An array of TObjects.
Definition: TObjArray.h:37
Mother of all ROOT objects.
Definition: TObject.h:37
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
Basic string class.
Definition: TString.h:131
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: StringConv.hxx:21
const UChar_t kTFOperShift
Definition: TFormula.h:33
const Int_t kTFOperMask
Definition: TFormula.h:32
const Int_t kMAXFOUND
Definition: TFormula.h:31