Logo ROOT   6.08/07
Reference Guide
TFormula.h
Go to the documentation of this file.
1 
2 // @(#)root/hist:$Id$
3 // Author: Maciej Zimnoch 30/09/2013
4 
5 /*************************************************************************
6  * Copyright (C) 1995-2013, Rene Brun and Fons Rademakers. *
7  * All rights reserved. *
8  * *
9  * For the licensing terms see $ROOTSYS/LICENSE. *
10  * For the list of contributors see $ROOTSYS/README/CREDITS. *
11  *************************************************************************/
12 // ---------------------------------- TFormula.h
13 #ifndef ROOT_TFormula
14 #define ROOT_TFormula
15 
16 
17 #ifndef ROOT_TNamed
18 #include "TNamed.h"
19 #endif
20  #ifndef ROOT_TBits
21 #include "TBits.h"
22 #endif
23 #ifndef ROOT_TObjArray
24 #include "TObjArray.h"
25 #endif
26 #include "TMethodCall.h"
27 #include "TInterpreter.h"
28 #include <vector>
29 #include <list>
30 #include <map>
31 
32 class TFormulaFunction
33 {
34 public:
35  TString fName;
36  TString fBody;
37  Int_t fNargs;
38  Bool_t fFound;
39  Bool_t fFuncCall;
40  const char * GetName() const { return fName.Data(); }
41  const char * GetBody() const { return fBody.Data(); }
42  Int_t GetNargs() const { return fNargs;}
43  Bool_t IsFuncCall() const { return fFuncCall;}
44  TFormulaFunction(){}
45  TFormulaFunction(const TString &name, const TString &body, int numArgs)
46  : fName(name),fBody(body),fNargs(numArgs),fFound(false),fFuncCall(true) {}
47  TFormulaFunction(const TString& name)
48  : fName(name),fBody(""),fNargs(0),fFound(false),fFuncCall(false){}
49  Bool_t operator<(const TFormulaFunction &rhv) const
50  {
51  // order by length - first the longer ones to avoid replacing wrong functions
52  if ( fName.Length() > rhv.fName.Length() )
53  return true;
54  else if ( fName.Length() > rhv.fName.Length() )
55  return false;
56  // case of equal length
57  return fName < rhv.fName && fBody < rhv.fBody;
58  }
59  Bool_t operator==(const TFormulaFunction &rhv) const
60  {
61  return fName == rhv.fName && fBody == rhv.fBody && fNargs == rhv.fNargs;
62  }
63 };
64 
65 class TFormulaVariable
66 {
67 public:
68  TString fName;
69  Double_t fValue;
70  Int_t fArrayPos;
71  Bool_t fFound;
72  const char * GetName() const { return fName.Data(); }
73  Double_t GetInitialValue() const { return fValue; }
74  Int_t GetArrayPos() const { return fArrayPos; }
75  TFormulaVariable():fName(""),fValue(-1),fArrayPos(-1),fFound(false){}
76  TFormulaVariable(const TString &name, Double_t value, Int_t pos)
77  : fName(name), fValue(value), fArrayPos(pos),fFound(false) {}
78  Bool_t operator<(const TFormulaVariable &rhv) const
79  {
80  return fName < rhv.fName;
81  }
82 };
83 
84 struct TFormulaParamOrder {
85  bool operator() (const TString& a, const TString& b) const;
86 };
87 
88 
89 class TFormula : public TNamed
90 {
91 private:
92 
93  // All data members are transient apart from the string defining the formula and the parameter values
94 
95  TString fClingInput; //! input function passed to Cling
96  std::vector<Double_t> fClingVariables; //! cached variables
97  std::vector<Double_t> fClingParameters; // parameter values
98  Bool_t fReadyToExecute; //! trasient to force initialization
99  Bool_t fClingInitialized; //! transient to force re-initialization
100  Bool_t fAllParametersSetted; // flag to control if all parameters are setted
101  TMethodCall* fMethod; //! pointer to methocall
102  TString fClingName; //! unique name passed to Cling to define the function ( double clingName(double*x, double*p) )
103 
104  TInterpreter::CallFuncIFacePtr_t::Generic_t fFuncPtr; //! function pointer
105  void * fLambdaPtr; //! pointer to the lambda function
106 
107  void InputFormulaIntoCling();
108  Bool_t PrepareEvalMethod();
109  void FillDefaults();
110  void HandlePolN(TString &formula);
111  void HandleParametrizedFunctions(TString &formula);
112  void HandleExponentiation(TString &formula);
113  void HandleLinear(TString &formula);
114  Bool_t InitLambdaExpression(const char * formula);
115  static Bool_t IsDefaultVariableName(const TString &name);
116 protected:
117 
118  std::list<TFormulaFunction> fFuncs; //!
119  std::map<TString,TFormulaVariable> fVars; //! list of variable names
120  std::map<TString,Int_t,TFormulaParamOrder> fParams; // list of parameter names
121  std::map<TString,Double_t> fConsts; //!
122  std::map<TString,TString> fFunctionsShortcuts; //!
123  TString fFormula;
124  Int_t fNdim; //!
125  Int_t fNpar; //!
126  Int_t fNumber; //!
127  std::vector<TObject*> fLinearParts; // vector of linear functions
128 
129  static Bool_t IsOperator(const char c);
130  static Bool_t IsBracket(const char c);
131  static Bool_t IsFunctionNameChar(const char c);
132  static Bool_t IsScientificNotation(const TString & formula, int ipos);
133  static Bool_t IsHexadecimal(const TString & formula, int ipos);
134  void ExtractFunctors(TString &formula);
135  void PreProcessFormula(TString &formula);
136  void ProcessFormula(TString &formula);
137  Bool_t PrepareFormula(TString &formula);
138  void ReplaceParamName(TString &formula, const TString & oldname, const TString & name);
139  void DoAddParameter(const TString &name, Double_t value, bool processFormula);
140  void DoSetParameters(const Double_t * p, Int_t size);
141  void SetPredefinedParamNames();
142 
143  Double_t DoEval(const Double_t * x, const Double_t * p = nullptr) const;
144 
145 public:
146 
147  enum {
148  kNotGlobal = BIT(10), // don't store in gROOT->GetListOfFunction (it should be protected)
149  kNormalized = BIT(14), // set to true if the TFormula (ex gausn) is normalized
150  kLinear = BIT(16), //set to true if the TFormula is for linear fitting
151  kLambda = BIT(17) // set to true if TFormula has been build with a lambda
152  };
153  TFormula();
154  virtual ~TFormula();
155  TFormula& operator=(const TFormula &rhs);
156  TFormula(const char *name, const char * formula = "", bool addToGlobList = true);
157  TFormula(const char *name, const char * formula, int ndim, int npar, bool addToGlobList = true);
158  TFormula(const TFormula &formula);
159  // TFormula(const char *name, Int_t nparams, Int_t ndims);
160 
161  void AddParameter(const TString &name, Double_t value = 0) { DoAddParameter(name,value,true); }
162  void AddVariable(const TString &name, Double_t value = 0);
163  void AddVariables(const TString *vars, const Int_t size);
164  Int_t Compile(const char *expression="");
165  virtual void Copy(TObject &f1) const;
166  virtual void Clear(Option_t * option="");
167  Double_t Eval(Double_t x) const;
168  Double_t Eval(Double_t x, Double_t y) const;
169  Double_t Eval(Double_t x, Double_t y , Double_t z) const;
170  Double_t Eval(Double_t x, Double_t y , Double_t z , Double_t t ) const;
171  Double_t EvalPar(const Double_t *x, const Double_t *params=0) const;
172  TString GetExpFormula(Option_t *option="") const;
173  const TObject *GetLinearPart(Int_t i) const;
174  Int_t GetNdim() const {return fNdim;}
175  Int_t GetNpar() const {return fNpar;}
176  Int_t GetNumber() const { return fNumber; }
177  const char * GetParName(Int_t ipar) const;
178  Int_t GetParNumber(const char * name) const;
179  Double_t GetParameter(const char * name) const;
180  Double_t GetParameter(Int_t param) const;
181  Double_t* GetParameters() const;
182  void GetParameters(Double_t *params) const;
183  Double_t GetVariable(const char *name) const;
184  Int_t GetVarNumber(const char *name) const;
185  TString GetVarName(Int_t ivar) const;
186  Bool_t IsValid() const { return fReadyToExecute && fClingInitialized; }
187  Bool_t IsLinear() const { return TestBit(kLinear); }
188  void Print(Option_t *option = "") const;
189  void SetName(const char* name);
190  void SetParameter(const char* name, Double_t value);
191  void SetParameter(Int_t param, Double_t value);
192  void SetParameters(const Double_t *params);
193  //void SetParameters(const pair<TString,Double_t> *params, const Int_t size);
194  void SetParameters(Double_t p0,Double_t p1,Double_t p2=0,Double_t p3=0,Double_t p4=0,
195  Double_t p5=0,Double_t p6=0,Double_t p7=0,Double_t p8=0,
196  Double_t p9=0,Double_t p10=0); // *MENU*
197  void SetParName(Int_t ipar, const char *name);
198  void SetParNames(const char *name0="p0",const char *name1="p1",const char
199  *name2="p2",const char *name3="p3",const char
200  *name4="p4", const char *name5="p5",const char *name6="p6",const char *name7="p7",const char
201  *name8="p8",const char *name9="p9",const char *name10="p10"); // *MENU*
202  void SetVariable(const TString &name, Double_t value);
203  void SetVariables(const std::pair<TString,Double_t> *vars, const Int_t size);
204 
205  ClassDef(TFormula,10)
206 };
207 #endif
p3
static double p3(double t, double a, double b, double c, double d)
Definition: RooChebychev.cxx:98
c
return c
Definition: entrylist_figure1.C:47
Option_t
const char Option_t
Definition: RtypesCore.h:62
TFormulaFunction::fName
TString fName
Definition: TFormula.h:35
BIT
#define BIT(n)
Definition: Rtypes.h:120
TFormulaFunction
Helper class for TFormula.
Definition: TFormula.h:32
TString
Basic string class.
Definition: TString.h:137
TFormulaParamOrder
Functor defining the parameter order.
Definition: TFormula.h:84
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
a
TArc * a
Definition: textangle.C:12
TFormulaFunction::fFound
Bool_t fFound
Definition: TFormula.h:38
TFormulaFunction::fBody
TString fBody
Definition: TFormula.h:36
SetParameters
void SetParameters(TFitEditor::FuncParams_t &pars, TF1 *func)
Restore the parameters from pars into the function.
Definition: TFitEditor.cxx:287
x
Double_t x[n]
Definition: legend1.C:17
ClassDef
#define ClassDef(name, id)
Definition: Rtypes.h:254
TFormulaFunction::IsFuncCall
Bool_t IsFuncCall() const
Definition: TFormula.h:43
TFormulaFunction::fFuncCall
Bool_t fFuncCall
Definition: TFormula.h:39
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition: TNamed.h:33
p2
static double p2(double t, double a, double b, double c)
Definition: RooChebychev.cxx:97
TInterpreter::CallFuncIFacePtr_t::Generic_t
void(* Generic_t)(void *, int, void **, void *)
Definition: TInterpreter.h:77
TFormulaFunction::operator==
Bool_t operator==(const TFormulaFunction &rhv) const
Definition: TFormula.h:59
TMethodCall
Method or function calling interface.
Definition: TMethodCall.h:41
TFormulaFunction::GetNargs
Int_t GetNargs() const
Definition: TFormula.h:42
fValue
PyObject * fValue
Definition: MethodProxy.cxx:120
TFormula
The F O R M U L A class.
Definition: TFormula.h:89
TFormulaFunction::GetName
const char * GetName() const
Definition: TFormula.h:40
TString::Length
Ssiz_t Length() const
Definition: TString.h:390
GetParameters
void GetParameters(TFitEditor::FuncParams_t &pars, TF1 *func)
Stores the parameters of the given function into pars.
Definition: TFitEditor.cxx:270
p1
static double p1(double t, double a, double b)
Definition: RooChebychev.cxx:96
TFormulaFunction::operator<
Bool_t operator<(const TFormulaFunction &rhv) const
Definition: TFormula.h:49
ROOT::Math::GSLSimAn::Copy
void Copy(void *source, void *dest)
Definition: GSLSimAnnealing.cxx:149
ROOT::Math::IntegOptionsUtil::Print
void Print(std::ostream &os, const OptionType &opt)
Definition: IntegratorOptions.cxx:91
Double_t
double Double_t
Definition: RtypesCore.h:55
y
Double_t y[n]
Definition: legend1.C:17
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TFormulaVariable::fName
TString fName
Definition: TFormula.h:68
z
you should not use this method at all Int_t Int_t z
Definition: TRolke.cxx:630
TFormulaFunction::GetBody
const char * GetBody() const
Definition: TFormula.h:41
f1
TF1 * f1
Definition: legend1.C:11
b
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
SetName
gr SetName("gr")
name
char name[80]
Definition: TGX11.cxx:109
TFormulaVariable
Another helper class for TFormula.
Definition: TFormula.h:65
TString::Data
const char * Data() const
Definition: TString.h:349