Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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"
29 
30 
31 const Int_t kMAXFOUND = 500;
32 const Int_t kTFOperMask = 0x7fffff;
33 const UChar_t kTFOperShift = 23;
34 
35 
36 
37 namespace ROOT {
38  namespace v5 {
39 
40  class TFormulaPrimitive;
41 
42 class TOperOffset {
43  friend class TFormula;
44 public:
45  enum {
46  kVariable = 0,
47  kParameter = 1,
48  kConstant = 2
49  };
50  TOperOffset();
51 protected:
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 };
63 
64 
65 class TFormula : public TNamed {
66 
67 protected:
68 
69  typedef Double_t (TObject::*TFuncG)(const Double_t*,const Double_t*) const;
70 
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
79 private:
80  Int_t *fOper; //[fNoper] List of operators. (See documentation for changes made at version 7)
81 protected:
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
89 
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
97 
98  Int_t PreCompile();
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);
101  virtual Bool_t StringToNumber(Int_t code);
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; }
106 
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; }
114 
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;
122 
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);
133 
134  // Action code for Version 6 and above.
135  enum {
136  kEnd = 0,
137  kAdd = 1, kSubstract = 2,
138  kMultiply = 3, kDivide = 4,
139  kModulo = 5,
140 
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 
148  kstrstr = 23,
149 
150  kmin = 24, kmax = 25,
151 
152  klog = 30, kexp = 31, klog10 = 32,
153 
154  kpi = 40,
155 
156  kabs = 41 , ksign= 42,
157  kint = 43 ,
158  kSignInv= 44 ,
159  krndm = 50 ,
160 
161  kAnd = 60, kOr = 61,
162  kEqual = 62, kNotEqual = 63,
163  kLess = 64, kGreater = 65,
164  kLessThan = 66, kGreaterThan = 67,
165  kNot = 68,
166 
167  kcosh = 70 , ksinh = 71, ktanh = 72,
168  kacosh = 73 , kasinh = 74, katanh = 75,
169 
170  kStringEqual = 76, kStringNotEqual = 77,
171 
172  kBitAnd = 78, kBitOr = 79,
173  kLeftShift = 80, kRightShift = 81,
174 
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 
182  kParameter = 140,
183  kConstant = 141,
184  kBoolOptimize = 142,
185  kStringConst = 143,
186  kVariable = 144,
187  kFunctionCall = 145,
188  kData = 146,
189  kUnary = 147,
190  kBinary = 148,
191  kThree = 149,
192  kDefinedVariable = 150,
193  kDefinedString = 151,
194  //
195  kPlusD = 152,
196  kPlusDD = 153,
197  kMultD = 154,
198  kMultDD = 155,
199  kBoolOptimizeOr = 156,
200  kBoolOptimizeAnd = 157,
201  kBoolSet = 158,
202  kFDM = 159,
203  kFD0 = 160,
204  kFD1 = 161,
205  kFD2 = 162,
206  kFD3 = 163
207  };
208 
209 public:
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);
220  TFormula& operator=(const TFormula &rhs);
221  virtual ~TFormula();
222 
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);
231  virtual Double_t DefinedValue(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