Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TF1.h
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Rene Brun 18/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// ---------------------------------- F1.h
12
13#ifndef ROOT_TF1
14#define ROOT_TF1
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TF1 //
19// //
20// The Parametric 1-D function //
21// //
22//////////////////////////////////////////////////////////////////////////
23
24#include "RConfigure.h"
25#include <functional>
26#include <cassert>
27#include <memory>
28#include <string>
29#include <vector>
30#include "TFormula.h"
31#include "TMethodCall.h"
32#include "TAttLine.h"
33#include "TAttFill.h"
34#include "TAttMarker.h"
35#include "TF1AbsComposition.h"
36#include "TMath.h"
37#include "Math/Types.h"
38#include "Math/ParamFunctor.h"
39
40#include <string>
41
42class TF1;
43class TH1;
44class TAxis;
45class TRandom;
46
47namespace ROOT {
48 namespace Fit {
49 class FitResult;
50 }
51}
52
54public:
55 TF1Parameters() {} // needed for the I/O
57 fParameters(std::vector<Double_t>(npar)),
58 fParNames(std::vector<std::string>(npar))
59 {
60 for (int i = 0; i < npar; ++i) {
61 fParNames[i] = std::string(TString::Format("p%d", i).Data());
62 }
63 }
64 // copy constructor
68 {}
69 // assignment
71 {
72 if (&rhs == this) return *this;
74 fParNames = rhs.fParNames;
75 return *this;
76 }
77 virtual ~TF1Parameters() {}
78
79 // getter methods
81 {
82 return (CheckIndex(iparam)) ? fParameters[iparam] : 0;
83 }
84 Double_t GetParameter(const char *name) const
85 {
87 }
88 const Double_t *GetParameters() const
89 {
90 return fParameters.data();
91 }
92 const std::vector<double> &ParamsVec() const
93 {
94 return fParameters;
95 }
96
97 Int_t GetParNumber(const char *name) const;
98
99 const char *GetParName(Int_t iparam) const
100 {
101 return (CheckIndex(iparam)) ? fParNames[iparam].c_str() : "";
102 }
103
104
105 // setter methods
107 {
108 if (!CheckIndex(iparam)) return;
109 fParameters[iparam] = value;
110 }
111 void SetParameters(const Double_t *params)
112 {
113 std::copy(params, params + fParameters.size(), fParameters.begin());
114 }
115 template <typename... Args>
116 void SetParameters(Double_t arg1, Args &&... args);
117
118 void SetParameter(const char *name, Double_t value)
119 {
121 }
122 void SetParName(Int_t iparam, const char *name)
123 {
124 if (!CheckIndex(iparam)) return;
125 fParNames[iparam] = std::string(name);
126 }
127 template <typename... Args>
128 void SetParNames(Args &&... args);
129
130 ClassDef(TF1Parameters, 1) // The Parameters of a parameteric function
131private:
132
133 bool CheckIndex(Int_t i) const
134 {
135 return (i >= 0 && i < int(fParameters.size()));
136 }
137
138 std::vector<Double_t> fParameters; // parameter values
139 std::vector<std::string> fParNames; // parameter names
140};
141
142/// Set parameter values.
143/// NaN values will be skipped, meaning that the corresponding parameters will not be changed.
144template <typename... Args>
145void TF1Parameters::SetParameters(Double_t arg1, Args &&...args)
146{
147 int i = 0;
148 for (double val : {arg1, static_cast<Double_t>(args)...}) {
149 if(!TMath::IsNaN(val)) SetParameter(i++, val);
150 }
151}
152
153/// Set parameter names.
154/// Empty strings will be skipped, meaning that the corresponding name will not be changed.
155template <typename... Args>
156void TF1Parameters::SetParNames(Args &&...args)
157{
158 int i = 0;
159 for (auto name : {static_cast<std::string const&>(args)...}) {
160 if(!name.empty()) SetParName(i++, name.c_str());
161 }
162}
163
164namespace ROOT {
165 namespace Internal {
166 /// %Internal class used by TF1 for defining
167 /// template specialization for different TF1 constructors
168 template<class Func>
169 struct TF1Builder {
170 static void Build(TF1 *f, Func func);
171 };
172
173 template<class Func>
174 struct TF1Builder<Func *> {
175 static void Build(TF1 *f, Func *func);
176 };
177
178 /// %Internal class used by TF1 for obtaining the type from a functor
179 /// out of the set of valid operator() signatures.
180 template<typename T>
182 };
183
184 template<typename F, typename T>
185 struct GetFunctorType<T(F::*)(const T *, const double *)> {
186 using type = T;
187 };
188
189 template<typename F, typename T>
190 struct GetFunctorType<T(F::*)(const T *, const double *) const> {
191 using type = T;
192 };
193
194 template<typename F, typename T>
195 struct GetFunctorType<T(F::*)(T *, double *)> {
196 using type = T;
197 };
198
199 template<typename F, typename T>
200 struct GetFunctorType<T(F::*)(T *, double *) const> {
201 using type = T;
202 };
203
204 /// %Internal class used by TF1 to get the right operator() signature
205 /// from a Functor with several ones.
206 template<typename T, typename F>
207 auto GetTheRightOp(T(F::*opPtr)(const T *, const double *)) -> decltype(opPtr)
208 {
209 return opPtr;
210 }
211
212 template<typename T, typename F>
213 auto GetTheRightOp(T(F::*opPtr)(const T *, const double *) const) -> decltype(opPtr)
214 {
215 return opPtr;
216 }
217
218 template<typename T, typename F>
219 auto GetTheRightOp(T(F::*opPtr)(T *, double *)) -> decltype(opPtr)
220 {
221 return opPtr;
222 }
223
224 template<typename T, typename F>
225 auto GetTheRightOp(T(F::*opPtr)(T *, double *) const) -> decltype(opPtr)
226 {
227 return opPtr;
228 }
229 }
230}
231
232
233class TF1 : public TNamed, public TAttLine, public TAttFill, public TAttMarker {
234
235 template<class Func>
237
238public:
239 /// Add to list behavior
240 enum class EAddToList {
241 kDefault,
242 kAdd,
243 kNo
244 };
245
246
249 virtual TF1FunctorPointer * Clone() const = 0;
250 };
251
252protected:
253
254 enum EFType {
255 kFormula = 0, ///< Formula functions which can be stored,
256 kPtrScalarFreeFcn, ///< Pointer to scalar free function,
257 kInterpreted, ///< Interpreted functions constructed by name,
258 kTemplVec, ///< Vectorized free functions or TemplScalar functors evaluating on vectorized parameters,
259 kTemplScalar, ///< TemplScalar functors evaluating on scalar parameters
261 }; // formula based on composition class (e.g. NSUM, CONV)
262
263 Double_t fXmin{-1111}; ///< Lower bounds for the range
264 Double_t fXmax{-1111}; ///< Upper bounds for the range
265 Int_t fNpar{}; ///< Number of parameters
266 Int_t fNdim{}; ///< Function dimension
267 Int_t fNpx{100}; ///< Number of points used for the graphical representation
269 Int_t fNpfits{}; ///< Number of points used in the fit
270 Int_t fNDF{}; ///< Number of degrees of freedom in the fit
271 Double_t fChisquare{}; ///< Function fit chisquare
272 Double_t fMinimum{-1111}; ///< Minimum value for plotting
273 Double_t fMaximum{-1111}; ///< Maximum value for plotting
274 std::vector<Double_t> fParErrors; ///< Array of errors of the fNpar parameters
275 std::vector<Double_t> fParMin; ///< Array of lower limits of the fNpar parameters
276 std::vector<Double_t> fParMax; ///< Array of upper limits of the fNpar parameters
277 std::vector<Double_t> fSave; ///< Array of fNsave function values
278 std::vector<Double_t> fIntegral; ///<! Integral of function binned on fNpx bins
279 std::vector<Double_t> fAlpha; ///<! Array alpha. for each bin in x the deconvolution r of fIntegral
280 std::vector<Double_t> fBeta; ///<! Array beta. is approximated by x = alpha +beta*r *gamma*r**2
281 std::vector<Double_t> fGamma; ///<! Array gamma.
282 TObject *fParent{nullptr}; ///<! Parent object hooking this function (if one)
283 TH1 *fHistogram{nullptr}; ///<! Pointer to histogram used for visualisation
284 std::unique_ptr<TMethodCall> fMethodCall; ///<! Pointer to MethodCall in case of interpreted function
285 Bool_t fNormalized{false}; ///< Normalization option (false by default)
286 Double_t fNormIntegral{}; ///< Integral of the function before being normalized
287 std::unique_ptr<TF1FunctorPointer> fFunctor; ///<! Functor object to wrap any C++ callable object
288 std::unique_ptr<TFormula> fFormula; ///< Pointer to TFormula in case when user define formula
289 std::unique_ptr<TF1Parameters> fParams; ///< Pointer to Function parameters object (exists only for not-formula functions)
290 std::unique_ptr<TF1AbsComposition> fComposition; ///< Pointer to composition (NSUM or CONV)
291
292 /// General constructor for TF1. Most of the other constructors delegate on it
293 TF1(EFType functionType, const char *name, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim, EAddToList addToGlobList, TF1Parameters *params = nullptr, TF1FunctorPointer * functor = nullptr):
294 TNamed(name, name), TAttLine(), TAttFill(), TAttMarker(), fXmin(xmin), fXmax(xmax), fNpar(npar), fNdim(ndim),
295 fType(functionType), fParErrors(npar), fParMin(npar), fParMax(npar)
296 {
297 fParams.reset(params);
298 fFunctor.reset(functor);
299 DoInitialize(addToGlobList);
300 }
301
302private:
303 // NSUM parsing helper functions
304 void DefineNSUMTerm(TObjArray *newFuncs, TObjArray *coeffNames,
305 TString &fullFormula,
306 TString &formula, int termStart, int termEnd,
308 int TermCoeffLength(TString &term);
309
310protected:
311
312 template <class T>
315 TF1FunctorPointerImpl(const std::function<T(const T *f, const Double_t *param)> &func) : fImpl(func){};
317 TF1FunctorPointer * Clone() const override { return new TF1FunctorPointerImpl<T>(fImpl); }
319 };
320
321
322
323
324 static std::atomic<Bool_t> fgAbsValue; //use absolute value of function when computing integral
325 static Bool_t fgRejectPoint; //True if point must be rejected in a fit
326 static std::atomic<Bool_t> fgAddToGlobList; //True if we want to register the function in the global list
327 static TF1 *fgCurrent; //pointer to current function being processed
328
329
330 //void CreateFromFunctor(const char *name, Int_t npar, Int_t ndim = 1);
331 void DoInitialize(EAddToList addToGlobList);
332
334 // tabulate the cumulative function integral at fNpx points. Used by GetRandom
336
337 virtual Double_t GetMinMaxNDim(Double_t *x , Bool_t findmax, Double_t epsilon = 0, Int_t maxiter = 0) const;
338 virtual void GetRange(Double_t *xmin, Double_t *xmax) const;
340
341public:
342
343 // TF1 status bits
345 kNotGlobal = BIT(10), // don't register in global list of functions
346 kNotDraw = BIT(9) // don't draw the function when in a TH1
347 };
348
349 TF1();
350 TF1(const char *name, const char *formula, Double_t xmin = 0, Double_t xmax = 1, EAddToList addToGlobList = EAddToList::kDefault, bool vectorize = false);
351 TF1(const char *name, const char *formula, Double_t xmin, Double_t xmax, Option_t * option); // same as above but using a string for option
352 TF1(const char *name, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault);
353 TF1(const char *name, Double_t (*fcn)(Double_t *, Double_t *), Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault);
354 TF1(const char *name, Double_t (*fcn)(const Double_t *, const Double_t *), Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault);
355
356 template <class T>
357 TF1(const char *name, std::function<T(const T *data, const Double_t *param)> &fcn, Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault):
358 TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<T>(fcn))
359 {
360 fType = std::is_same<T, double>::value ? TF1::EFType::kTemplScalar : TF1::EFType::kTemplVec;
361 }
362
363 ////////////////////////////////////////////////////////////////////////////////
364 /// Constructor using a pointer to function.
365 ///
366 /// \param[in] name object name
367 /// \param[in] fcn pointer to function
368 /// \param[in] xmin,xmax x axis limits
369 /// \param[in] npar is the number of free parameters used by the function
370 /// \param[in] ndim number of dimensions
371 /// \param[in] addToGlobList boolean marking if it should be added to global list
372 ///
373 /// This constructor creates a function of type C when invoked
374 /// with the normal C++ compiler.
375 ///
376 ///
377 /// \warning A function created with this constructor cannot be Cloned
378
379
380 template <class T>
381 TF1(const char *name, T(*fcn)(const T *, const Double_t *), Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault):
382 TF1(EFType::kTemplVec, name, xmin, xmax, npar, ndim, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<T>(fcn))
383 {}
384
385 // Constructors using functors (compiled mode only)
386 TF1(const char *name, ROOT::Math::ParamFunctor f, Double_t xmin = 0, Double_t xmax = 1, Int_t npar = 0, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault);
387
388 // Template constructors from any C++ callable object, defining the operator() (double * , double *)
389 // and returning a double.
390 // The class name is not needed when using compile code, while it is required when using
391 // interpreted code via the specialized constructor with void *.
392 // An instance of the C++ function class or its pointer can both be used. The former is reccomended when using
393 // C++ compiled code, but if CINT compatibility is needed, then a pointer to the function class must be used.
394 // xmin and xmax specify the plotting range, npar is the number of parameters.
395 // See the tutorial math/exampleFunctor.C for an example of using this constructor
396 template <typename Func>
397 TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault) :
398 TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList)
399 {
400 //actual fType set in TF1Builder
402 }
403
404 // backward compatible interface
405 template <typename Func>
406 TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
407 TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar))
408 {
410 }
411
412
413 // Template constructors from a pointer to any C++ class of type PtrObj with a specific member function of type
414 // MemFn.
415 // The member function must have the signature of (double * , double *) and returning a double.
416 // The class name and the method name are not needed when using compile code
417 // (the member function pointer is used in this case), while they are required when using interpreted
418 // code via the specialized constructor with void *.
419 // xmin and xmax specify the plotting range, npar is the number of parameters.
420 // See the tutorial math/exampleFunctor.C for an example of using this constructor
421 template <class PtrObj, typename MemFn>
422 TF1(const char *name, const PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim = 1, EAddToList addToGlobList = EAddToList::kDefault) :
423 TF1(EFType::kTemplScalar, name, xmin, xmax, npar, ndim, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))
424 {}
425
426 // backward compatible interface
427 template <class PtrObj, typename MemFn>
428 TF1(const char *name, const PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, const char *, const char *, EAddToList addToGlobList = EAddToList::kDefault) :
429 TF1(EFType::kTemplScalar, name, xmin, xmax, npar, 1, addToGlobList, new TF1Parameters(npar), new TF1FunctorPointerImpl<double>(ROOT::Math::ParamFunctor(p, memFn)))
430 {}
431
432 TF1(const TF1 &f1);
433 TF1 &operator=(const TF1 &rhs);
434 ~TF1() override;
435 virtual void AddParameter(const TString &name, Double_t value)
436 {
437 if (fFormula) fFormula->AddParameter(name, value);
438 }
439 // virtual void AddParameters(const pair<TString,Double_t> *pairs, Int_t size) { fFormula->AddParameters(pairs,size); }
440 // virtual void AddVariable(const TString &name, Double_t value = 0) { if (fFormula) fFormula->AddVariable(name,value); }
441 // virtual void AddVariables(const TString *vars, Int_t size) { if (fFormula) fFormula->AddVariables(vars,size); }
444 void Browse(TBrowser *b) override;
445 void Copy(TObject &f1) const override;
446 TObject *Clone(const char *newname = nullptr) const override;
447 virtual Double_t Derivative(Double_t x, Double_t *params = nullptr, Double_t epsilon = 0.001) const;
448 virtual Double_t Derivative2(Double_t x, Double_t *params = nullptr, Double_t epsilon = 0.001) const;
449 virtual Double_t Derivative3(Double_t x, Double_t *params = nullptr, Double_t epsilon = 0.001) const;
450 static Double_t DerivativeError();
451 Int_t DistancetoPrimitive(Int_t px, Int_t py) override;
452 void Draw(Option_t *option = "") override;
453 virtual TF1 *DrawCopy(Option_t *option = "") const;
454 virtual TObject *DrawDerivative(Option_t *option = "al"); // *MENU*
455 virtual TObject *DrawIntegral(Option_t *option = "al"); // *MENU*
456 virtual void DrawF1(Double_t xmin, Double_t xmax, Option_t *option = "");
457 virtual Double_t Eval(Double_t x, Double_t y = 0, Double_t z = 0, Double_t t = 0) const;
458 //template <class T> T Eval(T x, T y = 0, T z = 0, T t = 0) const;
459 virtual Double_t EvalPar(const Double_t *x, const Double_t *params = nullptr);
460 template <class T> T EvalPar(const T *x, const Double_t *params = nullptr);
461 virtual Double_t operator()(Double_t x, Double_t y = 0, Double_t z = 0, Double_t t = 0) const;
462 template <class T> T operator()(const T *x, const Double_t *params = nullptr);
463 void ExecuteEvent(Int_t event, Int_t px, Int_t py) override;
464 virtual void FixParameter(Int_t ipar, Double_t value);
466 {
467 return (fType == EFType::kTemplVec) || (fType == EFType::kFormula && fFormula && fFormula->IsVectorized());
468 }
469 /// Return the Chisquare after fitting. See ROOT::Fit::FitResult::Chi2()
471 {
472 return fChisquare;
473 }
474 virtual TH1 *GetHistogram() const;
476 {
478 }
480 {
481 return fFormula.get();
482 }
483 virtual const TFormula *GetFormula() const
484 {
485 return fFormula.get();
486 }
488 {
489 return (fFormula) ? fFormula->GetExpFormula(option) : TString();
490 }
491 virtual const TObject *GetLinearPart(Int_t i) const
492 {
493 return (fFormula) ? fFormula->GetLinearPart(i) : nullptr;
494 }
495 virtual Double_t GetMaximum(Double_t xmin = 0, Double_t xmax = 0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
496 virtual Double_t GetMinimum(Double_t xmin = 0, Double_t xmax = 0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
497 virtual Double_t GetMaximumX(Double_t xmin = 0, Double_t xmax = 0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
498 virtual Double_t GetMinimumX(Double_t xmin = 0, Double_t xmax = 0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
500 {
501 return fMaximum;
502 }
504 {
505 return fMinimum;
506 }
507 virtual Int_t GetNpar() const
508 {
509 return fNpar;
510 }
511 virtual Int_t GetNdim() const
512 {
513 return fNdim;
514 }
515 virtual Int_t GetNDF() const;
516 virtual Int_t GetNpx() const
517 {
518 return fNpx;
519 }
521 {
522 return fMethodCall.get();
523 }
524 virtual Int_t GetNumber() const
525 {
526 return (fFormula) ? fFormula->GetNumber() : 0;
527 }
528 virtual Int_t GetNumberFreeParameters() const;
529 virtual Int_t GetNumberFitPoints() const
530 {
531 return fNpfits;
532 }
533 char *GetObjectInfo(Int_t px, Int_t py) const override;
535 {
536 return fParent;
537 }
538 virtual Double_t GetParameter(Int_t ipar) const
539 {
540 return (fFormula) ? fFormula->GetParameter(ipar) : fParams->GetParameter(ipar);
541 }
542 virtual Double_t GetParameter(const TString &name) const
543 {
544 return (fFormula) ? fFormula->GetParameter(name) : fParams->GetParameter(name);
545 }
546 virtual Double_t *GetParameters() const
547 {
548 return (fFormula) ? fFormula->GetParameters() : const_cast<Double_t *>(fParams->GetParameters());
549 }
550 virtual void GetParameters(Double_t *params)
551 {
552 if (fFormula) fFormula->GetParameters(params);
553 else std::copy(fParams->ParamsVec().begin(), fParams->ParamsVec().end(), params);
554 }
555 virtual const char *GetParName(Int_t ipar) const
556 {
557 return (fFormula) ? fFormula->GetParName(ipar) : fParams->GetParName(ipar);
558 }
559 virtual Int_t GetParNumber(const char *name) const
560 {
561 return (fFormula) ? fFormula->GetParNumber(name) : fParams->GetParNumber(name);
562 }
563 virtual Double_t GetParError(Int_t ipar) const;
564 virtual const Double_t *GetParErrors() const
565 {
566 return fParErrors.data();
567 }
568 virtual void GetParLimits(Int_t ipar, Double_t &parmin, Double_t &parmax) const;
569 virtual Double_t GetProb() const;
570 virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum);
571 virtual Double_t GetRandom(TRandom * rng = nullptr, Option_t * opt = nullptr);
572 virtual Double_t GetRandom(Double_t xmin, Double_t xmax, TRandom * rng = nullptr, Option_t * opt = nullptr);
573 virtual void GetRange(Double_t &xmin, Double_t &xmax) const;
574 virtual void GetRange(Double_t &xmin, Double_t &ymin, Double_t &xmax, Double_t &ymax) const;
575 virtual void GetRange(Double_t &xmin, Double_t &ymin, Double_t &zmin, Double_t &xmax, Double_t &ymax, Double_t &zmax) const;
576 virtual Double_t GetSave(const Double_t *x);
577 virtual Double_t GetX(Double_t y, Double_t xmin = 0, Double_t xmax = 0, Double_t epsilon = 1.E-10, Int_t maxiter = 100, Bool_t logx = false) const;
578 virtual Double_t GetXmin() const
579 {
580 return fXmin;
581 }
582 virtual Double_t GetXmax() const
583 {
584 return fXmax;
585 }
586 TAxis *GetXaxis() const ;
587 TAxis *GetYaxis() const ;
588 TAxis *GetZaxis() const ;
590 {
591 return (fFormula) ? fFormula->GetVariable(name) : 0;
592 }
593 virtual Double_t GradientPar(Int_t ipar, const Double_t *x, Double_t eps = 0.01);
594 template <class T>
595 T GradientPar(Int_t ipar, const T *x, Double_t eps = 0.01);
596 template <class T>
597 T GradientParTempl(Int_t ipar, const T *x, Double_t eps = 0.01);
598
599 virtual void GradientPar(const Double_t *x, Double_t *grad, Double_t eps = 0.01);
600 template <class T>
601 void GradientPar(const T *x, T *grad, Double_t eps = 0.01);
602 template <class T>
603 void GradientParTempl(const T *x, T *grad, Double_t eps = 0.01);
604
605 virtual void InitArgs(const Double_t *x, const Double_t *params);
606 static void InitStandardFunctions();
607 virtual Double_t Integral(Double_t a, Double_t b, Double_t epsrel = 1.e-12);
608 virtual Double_t IntegralOneDim(Double_t a, Double_t b, Double_t epsrel, Double_t epsabs, Double_t &err);
609 virtual Double_t IntegralError(Double_t a, Double_t b, const Double_t *params = nullptr, const Double_t *covmat = nullptr, Double_t epsilon = 1.E-2);
610 virtual Double_t IntegralError(Int_t n, const Double_t *a, const Double_t *b, const Double_t *params = nullptr, const Double_t *covmat = nullptr, Double_t epsilon = 1.E-2);
611 // virtual Double_t IntegralFast(const TGraph *g, Double_t a, Double_t b, Double_t *params = nullptr);
612 virtual Double_t IntegralFast(Int_t num, Double_t *x, Double_t *w, Double_t a, Double_t b, Double_t *params = nullptr, Double_t epsilon = 1e-12);
613 virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Int_t maxpts, Double_t epsrel, Double_t epsabs , Double_t &relerr, Int_t &nfnevl, Int_t &ifail);
614 virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Int_t /*minpts*/, Int_t maxpts, Double_t epsrel, Double_t &relerr, Int_t &nfnevl, Int_t &ifail)
615 {
616 return IntegralMultiple(n, a, b, maxpts, epsrel, epsrel, relerr, nfnevl, ifail);
617 }
618 virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Double_t epsrel, Double_t &relerr);
619 virtual Bool_t IsEvalNormalized() const
620 {
621 return fNormalized;
622 }
623 /// return kTRUE if the point is inside the function range
624 virtual Bool_t IsInside(const Double_t *x) const
625 {
626 return !((x[0] < fXmin) || (x[0] > fXmax));
627 }
628 virtual Bool_t IsLinear() const
629 {
630 return (fFormula) ? fFormula->IsLinear() : false;
631 }
632 virtual Bool_t IsValid() const;
633 void Print(Option_t *option = "") const override;
634 void Paint(Option_t *option = "") override;
635 virtual void ReleaseParameter(Int_t ipar);
637 void SavePrimitive(std::ostream &out, Option_t *option = "") override;
638 virtual void SetChisquare(Double_t chi2)
639 {
640 fChisquare = chi2;
641 }
642 virtual void SetFitResult(const ROOT::Fit::FitResult &result, const Int_t *indpar = nullptr);
643 template <class PtrObj, typename MemFn>
644 void SetFunction(PtrObj &p, MemFn memFn);
645 template <typename Func>
646 void SetFunction(Func f);
647 virtual void SetMaximum(Double_t maximum = -1111); // *MENU*
648 virtual void SetMinimum(Double_t minimum = -1111); // *MENU*
649 virtual void SetNDF(Int_t ndf);
650 virtual void SetNumberFitPoints(Int_t npfits)
651 {
652 fNpfits = npfits;
653 }
654 virtual void SetNormalized(Bool_t flag)
655 {
656 fNormalized = flag;
657 Update();
658 }
659 virtual void SetNpx(Int_t npx = 100); // *MENU*
660 virtual void SetParameter(Int_t param, Double_t value)
661 {
662 (fFormula) ? fFormula->SetParameter(param, value) : fParams->SetParameter(param, value);
663 Update();
664 }
665 virtual void SetParameter(const TString &name, Double_t value)
666 {
667 (fFormula) ? fFormula->SetParameter(name, value) : fParams->SetParameter(name, value);
668 Update();
669 }
670 virtual void SetParameters(const Double_t *params)
671 {
672 (fFormula) ? fFormula->SetParameters(params) : fParams->SetParameters(params);
673 Update();
674 }
675 /// Set parameter values.
676 /// NaN values will be skipped, meaning that the corresponding parameters will not be changed.
677 virtual void SetParameters(double p0, double p1 = TMath::QuietNaN(), double p2 = TMath::QuietNaN(),
678 double p3 = TMath::QuietNaN(), double p4 = TMath::QuietNaN(), double p5 = TMath::QuietNaN(),
679 double p6 = TMath::QuietNaN(), double p7 = TMath::QuietNaN(), double p8 = TMath::QuietNaN(),
680 double p9 = TMath::QuietNaN(), double p10 = TMath::QuietNaN())
681 {
682 // Note: this is not made a variadic template method because it would
683 // presumably break the context menu in the TBrowser. Also, probably this
684 // method should not be virtual, because if the user wants to change
685 // parameter setting behavior, the SetParameter() method can be
686 // overridden.
687 if (fFormula) fFormula->SetParameters(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
688 else fParams->SetParameters(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
689 Update();
690 } // *MENU*
691 virtual void SetParName(Int_t ipar, const char *name);
692 virtual void SetParNames(const char *name0 = "", const char *name1 = "", const char *name2 = "",
693 const char *name3 = "", const char *name4 = "", const char *name5 = "",
694 const char *name6 = "", const char *name7 = "", const char *name8 = "",
695 const char *name9 = "", const char *name10 = ""); // *MENU*
696 virtual void SetParError(Int_t ipar, Double_t error);
697 virtual void SetParErrors(const Double_t *errors);
698 virtual void SetParLimits(Int_t ipar, Double_t parmin, Double_t parmax);
699 virtual void SetParent(TObject *p = nullptr)
700 {
701 fParent = p;
702 }
703 virtual void SetRange(Double_t xmin, Double_t xmax); // *MENU*
706 virtual void SetSavedPoint(Int_t point, Double_t value);
707 void SetTitle(const char *title = "") override; // *MENU*
708 virtual void SetVectorized(Bool_t vectorized)
709 {
711 fFormula->SetVectorized(vectorized);
712 else
713 Warning("SetVectorized", "Can only set vectorized flag on formula-based TF1");
714 }
715 virtual void Update();
716
717 static TF1 *GetCurrent();
718 static void AbsValue(Bool_t reject = kTRUE);
719 static void RejectPoint(Bool_t reject = kTRUE);
720 static Bool_t RejectedPoint();
721 static void SetCurrent(TF1 *f1);
722
723 //Moments
724 virtual Double_t Moment(Double_t n, Double_t a, Double_t b, const Double_t *params = nullptr, Double_t epsilon = 0.000001);
725 virtual Double_t CentralMoment(Double_t n, Double_t a, Double_t b, const Double_t *params = nullptr, Double_t epsilon = 0.000001);
726 virtual Double_t Mean(Double_t a, Double_t b, const Double_t *params = nullptr, Double_t epsilon = 0.000001)
727 {
728 return Moment(1, a, b, params, epsilon);
729 }
730 virtual Double_t Variance(Double_t a, Double_t b, const Double_t *params = nullptr, Double_t epsilon = 0.000001)
731 {
732 return CentralMoment(2, a, b, params, epsilon);
733 }
734
735 //some useful static utility functions to compute sampling points for Integral
736 //static void CalcGaussLegendreSamplingPoints(TGraph *g, Double_t eps=3.0e-11);
737 //static TGraph *CalcGaussLegendreSamplingPoints(Int_t num=21, Double_t eps=3.0e-11);
738 static void CalcGaussLegendreSamplingPoints(Int_t num, Double_t *x, Double_t *w, Double_t eps = 3.0e-11);
739
740private:
741 template <class T>
742 T EvalParTempl(const T *data, const Double_t *params = nullptr);
743
744#ifdef R__HAS_VECCORE
745 inline double EvalParVec(const Double_t *data, const Double_t *params);
746#endif
747
748 ClassDefOverride(TF1, 12) // The Parametric 1-D function
749};
750
751namespace ROOT {
752 namespace Internal {
753
754 template<class Func>
755 void TF1Builder<Func>::Build(TF1 *f, Func func)
756 {
757 using Fnc_t = typename ROOT::Internal::GetFunctorType<decltype(ROOT::Internal::GetTheRightOp(&Func::operator()))>::type;
758 f->fType = std::is_same<Fnc_t, double>::value? TF1::EFType::kTemplScalar : TF1::EFType::kTemplVec;
760 f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
761 }
762
763 template<class Func>
764 void TF1Builder<Func *>::Build(TF1 *f, Func *func)
765 {
766 using Fnc_t = typename ROOT::Internal::GetFunctorType<decltype(ROOT::Internal::GetTheRightOp(&Func::operator()))>::type;
767 f->fType = std::is_same<Fnc_t, double>::value? TF1::EFType::kTemplScalar : TF1::EFType::kTemplVec;
769 f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
770 }
771
772 /// TF1 building from a string
773 /// used to build a TFormula based on a lambda function
774 template<>
775 struct TF1Builder<const char *> {
776 static void Build(TF1 *f, const char *formula)
777 {
778 f->fType = TF1::EFType::kFormula;
779 f->fFormula = std::make_unique<TFormula>("tf1lambda", formula, f->fNdim, f->fNpar, false);
780 TString formulaExpression(formula);
781 Ssiz_t first = formulaExpression.Index("return") + 7;
782 Ssiz_t last = formulaExpression.Last(';');
783 TString title = formulaExpression(first, last - first);
784 f->SetTitle(title);
785 }
786 };
787 }
788}
789
791{
792 return Eval(x, y, z, t);
793}
794
795template <class T>
796inline T TF1::operator()(const T *x, const Double_t *params)
797{
798 return EvalPar(x, params);
799}
800
801////////////////////////////////////////////////////////////////////////////////
802/// EvalPar for vectorized
803template <class T>
804T TF1::EvalPar(const T *x, const Double_t *params)
805{
807 return EvalParTempl(x, params);
808 } else if (fType == EFType::kFormula) {
809 return fFormula->EvalPar(x, params);
810 } else
811 return TF1::EvalPar((double *)x, params);
812}
813
814////////////////////////////////////////////////////////////////////////////////
815/// Eval for vectorized functions
816// template <class T>
817// T TF1::Eval(T x, T y, T z, T t) const
818// {
819// if (fType == EFType::kFormula)
820// return fFormula->Eval(x, y, z, t);
821
822// T xx[] = {x, y, z, t};
823// Double_t *pp = (Double_t *)fParams->GetParameters();
824// return ((TF1 *)this)->EvalPar(xx, pp);
825// }
826
827// Internal to TF1. Evaluates Templated interfaces
828template <class T>
829inline T TF1::EvalParTempl(const T *data, const Double_t *params)
830{
832 if (!params) params = (Double_t *)fParams->GetParameters();
833 if (fFunctor)
834 return ((TF1FunctorPointerImpl<T> *)fFunctor.get())->fImpl(data, params);
835
836 // this should throw an error
837 // we nned to implement a vectorized GetSave(x)
838 return TMath::SignalingNaN();
839}
840
841#ifdef R__HAS_VECCORE
842// Internal to TF1. Evaluates Vectorized TF1 on data of type Double_v
843inline double TF1::EvalParVec(const Double_t *data, const Double_t *params)
844{
845 assert(fType == EFType::kTemplVec);
846 std::vector<ROOT::Double_v> d(fNdim);
847 ROOT::Double_v res;
848
849 for(auto i=0; i<fNdim; i++) {
850 d[i] = ROOT::Double_v(data[i]);
851 }
852
853 if (fFunctor) {
854 res = ((TF1FunctorPointerImpl<ROOT::Double_v> *) fFunctor.get())->fImpl(d.data(), params);
855 } else {
856 // res = GetSave(x);
857 return TMath::SignalingNaN();
858 }
859 return vecCore::Get<ROOT::Double_v>(res, 0);
860}
861#endif
862
864{
866}
868{
870}
871
872template <typename Func>
874{
875 // set function from a generic C++ callable object
877 fFunctor = std::make_unique<TF1::TF1FunctorPointerImpl<double>>(ROOT::Math::ParamFunctor(f));
878}
879template <class PtrObj, typename MemFn>
880void TF1::SetFunction(PtrObj &p, MemFn memFn)
881{
882 // set from a pointer to a member function
884 fFunctor = std::make_unique<TF1::TF1FunctorPointerImpl<double>>(ROOT::Math::ParamFunctor(p, memFn));
885}
886
887template <class T>
888inline T TF1::GradientPar(Int_t ipar, const T *x, Double_t eps)
889{
891 return GradientParTempl<T>(ipar, x, eps);
892 } else
893 return GradientParTempl<Double_t>(ipar, (const Double_t *)x, eps);
894}
895
896template <class T>
897inline T TF1::GradientParTempl(Int_t ipar, const T *x, Double_t eps)
898{
899 if (GetNpar() == 0)
900 return 0;
901
902 if (eps < 1e-10 || eps > 1) {
903 Warning("Derivative", "parameter esp=%g out of allowed range[1e-10,1], reset to 0.01", eps);
904 eps = 0.01;
905 }
906 Double_t h;
907 TF1 *func = (TF1 *)this;
908 Double_t *parameters = GetParameters();
909
910 // Copy parameters for thread safety
911 std::vector<Double_t> parametersCopy(parameters, parameters + GetNpar());
912 parameters = parametersCopy.data();
913
914 Double_t al, bl, h2;
915 T f1, f2, g1, g2, d0, d2;
916
917 ((TF1 *)this)->GetParLimits(ipar, al, bl);
918 if (al * bl != 0 && al >= bl) {
919 // this parameter is fixed
920 return 0;
921 }
922
923 // check if error has been computer (is not zero)
924 if (func->GetParError(ipar) != 0)
925 h = eps * func->GetParError(ipar);
926 else
927 h = eps;
928
929 // save original parameters
930 Double_t par0 = parameters[ipar];
931
932 parameters[ipar] = par0 + h;
933 f1 = func->EvalPar(x, parameters);
934 parameters[ipar] = par0 - h;
935 f2 = func->EvalPar(x, parameters);
936 parameters[ipar] = par0 + h / 2;
937 g1 = func->EvalPar(x, parameters);
938 parameters[ipar] = par0 - h / 2;
939 g2 = func->EvalPar(x, parameters);
940
941 // compute the central differences
942 h2 = 1 / (2. * h);
943 d0 = f1 - f2;
944 d2 = 2 * (g1 - g2);
945
946 T grad = h2 * (4 * d2 - d0) / 3.;
947
948 // restore original value
949 parameters[ipar] = par0;
950
951 return grad;
952}
953
954template <class T>
955inline void TF1::GradientPar(const T *x, T *grad, Double_t eps)
956{
958 GradientParTempl<T>(x, grad, eps);
959 } else
960 GradientParTempl<Double_t>((const Double_t *)x, (Double_t *)grad, eps);
961}
962
963template <class T>
964inline void TF1::GradientParTempl(const T *x, T *grad, Double_t eps)
965{
966 if (eps < 1e-10 || eps > 1) {
967 Warning("Derivative", "parameter esp=%g out of allowed range[1e-10,1], reset to 0.01", eps);
968 eps = 0.01;
969 }
970
971 for (Int_t ipar = 0; ipar < GetNpar(); ipar++) {
972 grad[ipar] = GradientParTempl<T>(ipar, x, eps);
973 }
974}
975
976#endif
#define d(i)
Definition RSha256.hxx:102
#define b(i)
Definition RSha256.hxx:100
#define f(i)
Definition RSha256.hxx:104
#define a(i)
Definition RSha256.hxx:99
#define h(i)
Definition RSha256.hxx:106
#define e(i)
Definition RSha256.hxx:103
bool Bool_t
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
constexpr Bool_t kFALSE
Definition RtypesCore.h:101
double Double_t
Definition RtypesCore.h:59
constexpr Bool_t kTRUE
Definition RtypesCore.h:100
const char Option_t
Definition RtypesCore.h:66
#define ClassDef(name, id)
Definition Rtypes.h:337
#define BIT(n)
Definition Rtypes.h:85
#define ClassDefOverride(name, id)
Definition Rtypes.h:341
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t option
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void on
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
Definition TGX11.cxx:110
float xmin
float * q
float ymin
float xmax
float ymax
class containing the result of the fit and all the related information (fitted parameter values,...
Definition FitResult.h:47
Param Functor class for Multidimensional functions.
Fill Area Attributes class.
Definition TAttFill.h:19
Line Attributes class.
Definition TAttLine.h:18
Marker Attributes class.
Definition TAttMarker.h:19
Class to manage histogram axis.
Definition TAxis.h:31
Using a TBrowser one can browse all ROOT objects.
Definition TBrowser.h:37
TF1 Parameters class.
Definition TF1.h:53
std::vector< Double_t > fParameters
Definition TF1.h:138
const char * GetParName(Int_t iparam) const
Definition TF1.h:99
const std::vector< double > & ParamsVec() const
Definition TF1.h:92
virtual ~TF1Parameters()
Definition TF1.h:77
Double_t GetParameter(const char *name) const
Definition TF1.h:84
Double_t GetParameter(Int_t iparam) const
Definition TF1.h:80
void SetParName(Int_t iparam, const char *name)
Definition TF1.h:122
TF1Parameters & operator=(const TF1Parameters &rhs)
Definition TF1.h:70
void SetParameter(Int_t iparam, Double_t value)
Definition TF1.h:106
void SetParameter(const char *name, Double_t value)
Definition TF1.h:118
TF1Parameters(Int_t npar)
Definition TF1.h:56
std::vector< std::string > fParNames
Definition TF1.h:139
TF1Parameters()
Definition TF1.h:55
bool CheckIndex(Int_t i) const
Definition TF1.h:133
void SetParNames(Args &&... args)
Set parameter names.
Definition TF1.h:156
void SetParameters(const Double_t *params)
Definition TF1.h:111
Int_t GetParNumber(const char *name) const
Returns the parameter number given a name not very efficient but list of parameters is typically smal...
Definition TF1.cxx:3846
TF1Parameters(const TF1Parameters &rhs)
Definition TF1.h:65
const Double_t * GetParameters() const
Definition TF1.h:88
1-Dim function class
Definition TF1.h:233
std::unique_ptr< TF1FunctorPointer > fFunctor
! Functor object to wrap any C++ callable object
Definition TF1.h:287
virtual Double_t GetMinimumX(Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the X value corresponding to the minimum value of the function on the (xmin,...
Definition TF1.cxx:1825
virtual Double_t GetMinimum(Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the minimum value of the function on the (xmin, xmax) interval.
Definition TF1.cxx:1698
virtual Double_t GetXmax() const
Definition TF1.h:582
virtual void ReleaseParameter(Int_t ipar)
Release parameter number ipar during a fit operation.
Definition TF1.cxx:3151
virtual void SetParError(Int_t ipar, Double_t error)
Set error for parameter number ipar.
Definition TF1.cxx:3479
static void RejectPoint(Bool_t reject=kTRUE)
Static function to set the global flag to reject points the fgRejectPoint global flag is tested by al...
Definition TF1.cxx:3683
EAddToList
Add to list behavior.
Definition TF1.h:240
virtual Double_t Mean(Double_t a, Double_t b, const Double_t *params=nullptr, Double_t epsilon=0.000001)
Definition TF1.h:726
virtual Double_t Derivative(Double_t x, Double_t *params=nullptr, Double_t epsilon=0.001) const
Returns the first derivative of the function at point x, computed by Richardson's extrapolation metho...
Definition TF1.cxx:1115
virtual const Double_t * GetParErrors() const
Definition TF1.h:564
virtual Int_t GetNumber() const
Definition TF1.h:524
virtual Int_t GetNDF() const
Return the number of degrees of freedom in the fit the fNDF parameter has been previously computed du...
Definition TF1.cxx:1891
std::vector< Double_t > fParErrors
Array of errors of the fNpar parameters.
Definition TF1.h:274
Int_t fNdim
Function dimension.
Definition TF1.h:266
static void CalcGaussLegendreSamplingPoints(Int_t num, Double_t *x, Double_t *w, Double_t eps=3.0e-11)
Type safe interface (static method) The number of sampling points are taken from the TGraph.
Definition TF1.cxx:3826
static void AbsValue(Bool_t reject=kTRUE)
Static function: set the fgAbsValue flag.
Definition TF1.cxx:986
virtual TH1 * GetHistogram() const
Return a pointer to the histogram used to visualise the function Note that this histogram is managed ...
Definition TF1.cxx:1586
virtual const TFormula * GetFormula() const
Definition TF1.h:483
virtual void GetParLimits(Int_t ipar, Double_t &parmin, Double_t &parmax) const
Return limits for parameter ipar.
Definition TF1.cxx:1942
Int_t fNpar
Number of parameters.
Definition TF1.h:265
virtual Double_t GetParameter(const TString &name) const
Definition TF1.h:542
TAxis * GetYaxis() const
Get y axis of the function.
Definition TF1.cxx:2411
virtual void GetParameters(Double_t *params)
Definition TF1.h:550
virtual void SetNDF(Int_t ndf)
Set the number of degrees of freedom ndf should be the number of points used in a fit - the number of...
Definition TF1.cxx:3419
virtual Double_t GetParError(Int_t ipar) const
Return value of parameter number ipar.
Definition TF1.cxx:1932
static std::atomic< Bool_t > fgAddToGlobList
Definition TF1.h:326
virtual Bool_t IsEvalNormalized() const
Definition TF1.h:619
virtual Double_t GetVariable(const TString &name)
Definition TF1.h:589
virtual Double_t IntegralError(Double_t a, Double_t b, const Double_t *params=nullptr, const Double_t *covmat=nullptr, Double_t epsilon=1.E-2)
Return Error on Integral of a parametric function between a and b due to the parameter uncertainties ...
Definition TF1.cxx:2708
virtual void SetChisquare(Double_t chi2)
Definition TF1.h:638
virtual Double_t IntegralFast(Int_t num, Double_t *x, Double_t *w, Double_t a, Double_t b, Double_t *params=nullptr, Double_t epsilon=1e-12)
Gauss-Legendre integral, see CalcGaussLegendreSamplingPoints.
Definition TF1.cxx:2778
Double_t fNormIntegral
Integral of the function before being normalized.
Definition TF1.h:286
Double_t GetChisquare() const
Return the Chisquare after fitting. See ROOT::Fit::FitResult::Chi2()
Definition TF1.h:470
virtual void SetMaximum(Double_t maximum=-1111)
Set the maximum value along Y for this function In case the function is already drawn,...
Definition TF1.cxx:3394
void Print(Option_t *option="") const override
This method must be overridden when a class wants to print itself.
Definition TF1.cxx:2897
T GradientParTempl(Int_t ipar, const T *x, Double_t eps=0.01)
Definition TF1.h:897
virtual TH1 * CreateHistogram()
Definition TF1.h:475
Double_t fXmin
Lower bounds for the range.
Definition TF1.h:263
std::unique_ptr< TMethodCall > fMethodCall
! Pointer to MethodCall in case of interpreted function
Definition TF1.h:284
virtual void Update()
Called by functions such as SetRange, SetNpx, SetParameters to force the deletion of the associated h...
Definition TF1.cxx:3619
virtual Double_t GetProb() const
Return the fit probability.
Definition TF1.cxx:1957
void IntegrateForNormalization()
TF1(const char *name, std::function< T(const T *data, const Double_t *param)> &fcn, Double_t xmin=0, Double_t xmax=1, Int_t npar=0, Int_t ndim=1, EAddToList addToGlobList=EAddToList::kDefault)
Definition TF1.h:357
virtual Double_t GradientPar(Int_t ipar, const Double_t *x, Double_t eps=0.01)
Compute the gradient (derivative) wrt a parameter ipar.
Definition TF1.cxx:2445
TAxis * GetZaxis() const
Get z axis of the function. (In case this object is a TF2 or TF3)
Definition TF1.cxx:2422
virtual Double_t GetRandom(TRandom *rng=nullptr, Option_t *opt=nullptr)
Return a random number following this function shape.
Definition TF1.cxx:2192
virtual void SetRange(Double_t xmin, Double_t xmax)
Initialize the upper and lower bounds to draw the function.
Definition TF1.cxx:3528
virtual Double_t GetMaximumStored() const
Definition TF1.h:499
virtual Int_t GetNpar() const
Definition TF1.h:507
virtual TString GetExpFormula(Option_t *option="") const
Definition TF1.h:487
std::vector< Double_t > fBeta
! Array beta. is approximated by x = alpha +beta*r *gamma*r**2
Definition TF1.h:280
Int_t fNDF
Number of degrees of freedom in the fit.
Definition TF1.h:270
TH1 * fHistogram
! Pointer to histogram used for visualisation
Definition TF1.h:283
virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Int_t, Int_t maxpts, Double_t epsrel, Double_t &relerr, Int_t &nfnevl, Int_t &ifail)
Definition TF1.h:614
std::unique_ptr< TF1AbsComposition > fComposition
Pointer to composition (NSUM or CONV)
Definition TF1.h:290
virtual void SetParErrors(const Double_t *errors)
Set errors for all active parameters when calling this function, the array errors must have at least ...
Definition TF1.cxx:3490
virtual TH1 * DoCreateHistogram(Double_t xmin, Double_t xmax, Bool_t recreate=kFALSE)
Create histogram with bin content equal to function value computed at the bin center This histogram w...
Definition TF1.cxx:3048
TObject * GetParent() const
Definition TF1.h:534
Int_t fNpfits
Number of points used in the fit.
Definition TF1.h:269
virtual Double_t Derivative2(Double_t x, Double_t *params=nullptr, Double_t epsilon=0.001) const
Returns the second derivative of the function at point x, computed by Richardson's extrapolation meth...
Definition TF1.cxx:1180
static void SetCurrent(TF1 *f1)
Static function setting the current function.
Definition TF1.cxx:3343
void SetFunction(PtrObj &p, MemFn memFn)
Definition TF1.h:880
virtual void SetParent(TObject *p=nullptr)
Definition TF1.h:699
std::vector< Double_t > fAlpha
! Array alpha. for each bin in x the deconvolution r of fIntegral
Definition TF1.h:279
TF1(const char *name, const PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, const char *, const char *, EAddToList addToGlobList=EAddToList::kDefault)
Definition TF1.h:428
virtual Double_t Integral(Double_t a, Double_t b, Double_t epsrel=1.e-12)
IntegralOneDim or analytical integral.
Definition TF1.cxx:2531
void SetTitle(const char *title="") override
Set function title if title has the form "fffffff;xxxx;yyyy", it is assumed that the function title i...
Definition TF1.cxx:3558
virtual Int_t GetNumberFitPoints() const
Definition TF1.h:529
std::unique_ptr< TFormula > fFormula
Pointer to TFormula in case when user define formula.
Definition TF1.h:288
virtual 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.
Definition TF1.cxx:3463
static Double_t DerivativeError()
Static function returning the error of the last call to the of Derivative's functions.
Definition TF1.cxx:1279
std::vector< Double_t > fParMin
Array of lower limits of the fNpar parameters.
Definition TF1.h:275
static void InitStandardFunctions()
Create the basic function objects.
Definition TF1.cxx:2497
Double_t fMaximum
Maximum value for plotting.
Definition TF1.h:273
virtual void SetNpx(Int_t npx=100)
Set the number of points used to draw the function.
Definition TF1.cxx:3433
virtual Double_t * GetParameters() const
Definition TF1.h:546
Double_t fMinimum
Minimum value for plotting.
Definition TF1.h:272
int TermCoeffLength(TString &term)
Definition TF1.cxx:926
static Bool_t fgRejectPoint
Definition TF1.h:325
void Copy(TObject &f1) const override
Copy this F1 to a new F1.
Definition TF1.cxx:1007
virtual void SetNumberFitPoints(Int_t npfits)
Definition TF1.h:650
virtual Double_t GetMinimumStored() const
Definition TF1.h:503
virtual void SetNormalized(Bool_t flag)
Definition TF1.h:654
void Paint(Option_t *option="") override
Paint this function with its current attributes.
Definition TF1.cxx:2953
TF1 & operator=(const TF1 &rhs)
Operator =.
Definition TF1.cxx:944
virtual Int_t GetNumberFreeParameters() const
Return the number of free parameters.
Definition TF1.cxx:1902
virtual Double_t Moment(Double_t n, Double_t a, Double_t b, const Double_t *params=nullptr, Double_t epsilon=0.000001)
Return nth moment of function between a and b.
Definition TF1.cxx:3702
virtual Double_t CentralMoment(Double_t n, Double_t a, Double_t b, const Double_t *params=nullptr, Double_t epsilon=0.000001)
Return nth central moment of function between a and b (i.e the n-th moment around the mean value)
Definition TF1.cxx:3739
TF1(const char *name, const PtrObj &p, MemFn memFn, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim=1, EAddToList addToGlobList=EAddToList::kDefault)
Definition TF1.h:422
Double_t fChisquare
Function fit chisquare.
Definition TF1.h:271
EStatusBits
Definition TF1.h:344
@ kNotGlobal
Definition TF1.h:345
@ kNotDraw
Definition TF1.h:346
virtual TFormula * GetFormula()
Definition TF1.h:479
virtual void InitArgs(const Double_t *x, const Double_t *params)
Initialize parameters addresses.
Definition TF1.cxx:2482
TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, const char *, EAddToList addToGlobList=EAddToList::kDefault)
Definition TF1.h:406
virtual Double_t IntegralMultiple(Int_t n, const Double_t *a, const Double_t *b, Int_t maxpts, Double_t epsrel, Double_t epsabs, Double_t &relerr, Int_t &nfnevl, Int_t &ifail)
This function computes, to an attempted specified accuracy, the value of the integral.
Definition TF1.cxx:2851
TMethodCall * GetMethodCall() const
Definition TF1.h:520
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute distance from point px,py to a function.
Definition TF1.cxx:1295
virtual Double_t operator()(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const
Definition TF1.h:790
EFType fType
Definition TF1.h:268
Bool_t fNormalized
Normalization option (false by default)
Definition TF1.h:285
virtual Double_t Variance(Double_t a, Double_t b, const Double_t *params=nullptr, Double_t epsilon=0.000001)
Definition TF1.h:730
virtual void SetMinimum(Double_t minimum=-1111)
Set the minimum value along Y for this function In case the function is already drawn,...
Definition TF1.cxx:3407
virtual void AddParameter(const TString &name, Double_t value)
Definition TF1.h:435
virtual void GetRange(Double_t *xmin, Double_t *xmax) const
Return range of a generic N-D function.
Definition TF1.cxx:2281
void Browse(TBrowser *b) override
Browse.
Definition TF1.cxx:995
virtual const char * GetParName(Int_t ipar) const
Definition TF1.h:555
~TF1() override
TF1 default destructor.
Definition TF1.cxx:955
static TF1 * fgCurrent
Definition TF1.h:327
virtual Double_t EvalPar(const Double_t *x, const Double_t *params=nullptr)
Evaluate function with given coordinates and parameters.
Definition TF1.cxx:1470
TF1(EFType functionType, const char *name, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim, EAddToList addToGlobList, TF1Parameters *params=nullptr, TF1FunctorPointer *functor=nullptr)
General constructor for TF1. Most of the other constructors delegate on it.
Definition TF1.h:293
Int_t fNpx
Number of points used for the graphical representation.
Definition TF1.h:267
virtual void SetParLimits(Int_t ipar, Double_t parmin, Double_t parmax)
Set lower and upper limits for parameter ipar.
Definition TF1.cxx:3507
void DoInitialize(EAddToList addToGlobList)
Common initialization of the TF1.
Definition TF1.cxx:804
virtual Double_t GetX(Double_t y, Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the X value corresponding to the function value fy for (xmin<x<xmax).
Definition TF1.cxx:1865
static TF1 * GetCurrent()
Static function returning the current function being processed.
Definition TF1.cxx:1571
virtual Int_t GetQuantiles(Int_t nprobSum, Double_t *q, const Double_t *probSum)
Compute Quantiles for density distribution of this function.
Definition TF1.cxx:1994
virtual void SetParName(Int_t ipar, const char *name)
Set name of parameter number ipar.
Definition TF1.cxx:3450
char * GetObjectInfo(Int_t px, Int_t py) const override
Redefines TObject::GetObjectInfo.
Definition TF1.cxx:1920
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute action corresponding to one event.
Definition TF1.cxx:1538
virtual Double_t GetSave(const Double_t *x)
Get value corresponding to X in array of fSave values.
Definition TF1.cxx:2344
static std::atomic< Bool_t > fgAbsValue
Definition TF1.h:324
virtual Bool_t IsLinear() const
Definition TF1.h:628
virtual void SetParameters(double p0, double p1=TMath::QuietNaN(), double p2=TMath::QuietNaN(), double p3=TMath::QuietNaN(), double p4=TMath::QuietNaN(), double p5=TMath::QuietNaN(), double p6=TMath::QuietNaN(), double p7=TMath::QuietNaN(), double p8=TMath::QuietNaN(), double p9=TMath::QuietNaN(), double p10=TMath::QuietNaN())
Set parameter values.
Definition TF1.h:677
TF1()
TF1 default constructor.
Definition TF1.cxx:489
virtual TF1 * DrawCopy(Option_t *option="") const
Draw a copy of this function with its current attributes.
Definition TF1.cxx:1365
std::vector< Double_t > fParMax
Array of upper limits of the fNpar parameters.
Definition TF1.h:276
bool IsVectorized()
Definition TF1.h:465
void SavePrimitive(std::ostream &out, Option_t *option="") override
Save primitive as a C++ statement(s) on output stream out.
Definition TF1.cxx:3218
virtual Bool_t IsValid() const
Return kTRUE if the function is valid.
Definition TF1.cxx:2882
static Bool_t DefaultAddToGlobalList(Bool_t on=kTRUE)
Static method to add/avoid to add automatically functions to the global list (gROOT->GetListOfFunctio...
Definition TF1.cxx:840
std::vector< Double_t > fSave
Array of fNsave function values.
Definition TF1.h:277
static Bool_t RejectedPoint()
See TF1::RejectPoint above.
Definition TF1.cxx:3692
void DefineNSUMTerm(TObjArray *newFuncs, TObjArray *coeffNames, TString &fullFormula, TString &formula, int termStart, int termEnd, Double_t xmin, Double_t xmax)
Helper functions for NSUM parsing.
Definition TF1.cxx:885
std::vector< Double_t > fGamma
! Array gamma.
Definition TF1.h:281
TObject * fParent
! Parent object hooking this function (if one)
Definition TF1.h:282
virtual Double_t GetMinMaxNDim(Double_t *x, Bool_t findmax, Double_t epsilon=0, Int_t maxiter=0) const
Find the minimum of a function of whatever dimension.
Definition TF1.cxx:1725
virtual void DrawF1(Double_t xmin, Double_t xmax, Option_t *option="")
Draw function between xmin and xmax.
Definition TF1.cxx:1422
Bool_t ComputeCdfTable(Option_t *opt)
Compute the cumulative function at fNpx points between fXmin and fXmax.
Definition TF1.cxx:2081
virtual void SetParameters(const Double_t *params)
Definition TF1.h:670
T EvalParTempl(const T *data, const Double_t *params=nullptr)
Eval for vectorized functions.
Definition TF1.h:829
virtual TObject * DrawIntegral(Option_t *option="al")
Draw integral of this function.
Definition TF1.cxx:1409
std::vector< Double_t > fIntegral
! Integral of function binned on fNpx bins
Definition TF1.h:278
virtual TObject * DrawDerivative(Option_t *option="al")
Draw derivative of this function.
Definition TF1.cxx:1387
virtual Double_t Eval(Double_t x, Double_t y=0, Double_t z=0, Double_t t=0) const
Evaluate this function.
Definition TF1.cxx:1441
virtual Double_t GetMaximum(Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the maximum value of the function.
Definition TF1.cxx:1616
std::unique_ptr< TF1Parameters > fParams
Pointer to Function parameters object (exists only for not-formula functions)
Definition TF1.h:289
virtual void SetParameter(const TString &name, Double_t value)
Definition TF1.h:665
virtual void SetParameter(Int_t param, Double_t value)
Definition TF1.h:660
virtual Double_t Derivative3(Double_t x, Double_t *params=nullptr, Double_t epsilon=0.001) const
Returns the third derivative of the function at point x, computed by Richardson's extrapolation metho...
Definition TF1.cxx:1245
virtual void Save(Double_t xmin, Double_t xmax, Double_t ymin, Double_t ymax, Double_t zmin, Double_t zmax)
Save values of function in array fSave.
Definition TF1.cxx:3161
TObject * Clone(const char *newname=nullptr) const override
Make a complete copy of the underlying object.
Definition TF1.cxx:1066
EFType
Definition TF1.h:254
@ kCompositionFcn
Definition TF1.h:260
@ kFormula
Formula functions which can be stored,.
Definition TF1.h:255
@ kPtrScalarFreeFcn
Pointer to scalar free function,.
Definition TF1.h:256
@ kTemplScalar
TemplScalar functors evaluating on scalar parameters.
Definition TF1.h:259
@ kTemplVec
Vectorized free functions or TemplScalar functors evaluating on vectorized parameters,...
Definition TF1.h:258
@ kInterpreted
Interpreted functions constructed by name,.
Definition TF1.h:257
virtual void SetSavedPoint(Int_t point, Double_t value)
Restore value of function saved at point.
Definition TF1.cxx:3542
virtual void FixParameter(Int_t ipar, Double_t value)
Fix the value of a parameter for a fit operation The specified value will be used in the fit and the ...
Definition TF1.cxx:1559
virtual Bool_t IsInside(const Double_t *x) const
return kTRUE if the point is inside the function range
Definition TF1.h:624
virtual Int_t GetNpx() const
Definition TF1.h:516
Double_t fXmax
Upper bounds for the range.
Definition TF1.h:264
virtual Double_t GetMaximumX(Double_t xmin=0, Double_t xmax=0, Double_t epsilon=1.E-10, Int_t maxiter=100, Bool_t logx=false) const
Returns the X value corresponding to the maximum value of the function.
Definition TF1.cxx:1657
virtual Int_t GetNdim() const
Definition TF1.h:511
virtual Double_t GetXmin() const
Definition TF1.h:578
virtual Bool_t AddToGlobalList(Bool_t on=kTRUE)
Add to global list of functions (gROOT->GetListOfFunctions() ) return previous status (true if the fu...
Definition TF1.cxx:849
virtual const TObject * GetLinearPart(Int_t i) const
Definition TF1.h:491
virtual void SetVectorized(Bool_t vectorized)
Definition TF1.h:708
virtual Double_t IntegralOneDim(Double_t a, Double_t b, Double_t epsrel, Double_t epsabs, Double_t &err)
Return Integral of function between a and b using the given parameter values and relative and absolut...
Definition TF1.cxx:2621
TF1(const char *name, Func f, Double_t xmin, Double_t xmax, Int_t npar, Int_t ndim=1, EAddToList addToGlobList=EAddToList::kDefault)
Definition TF1.h:397
virtual Double_t GetParameter(Int_t ipar) const
Definition TF1.h:538
virtual Int_t GetParNumber(const char *name) const
Definition TF1.h:559
TF1(const char *name, T(*fcn)(const T *, const Double_t *), Double_t xmin=0, Double_t xmax=1, Int_t npar=0, Int_t ndim=1, EAddToList addToGlobList=EAddToList::kDefault)
Constructor using a pointer to function.
Definition TF1.h:381
virtual void SetFitResult(const ROOT::Fit::FitResult &result, const Int_t *indpar=nullptr)
Set the result from the fit parameter values, errors, chi2, etc... Optionally a pointer to a vector (...
Definition TF1.cxx:3355
TAxis * GetXaxis() const
Get x axis of the function.
Definition TF1.cxx:2400
The Formula class.
Definition TFormula.h:89
TH1 is the base class of all histogram classes in ROOT.
Definition TH1.h:59
Method or function calling interface.
Definition TMethodCall.h:37
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
An array of TObjects.
Definition TObjArray.h:31
Mother of all ROOT objects.
Definition TObject.h:41
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:962
This is the base class for the ROOT Random number generators.
Definition TRandom.h:27
Basic string class.
Definition TString.h:139
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition TString.cxx:931
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2378
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Definition TString.h:653
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
const Int_t n
Definition legend1.C:16
TF1 * f1
Definition legend1.C:11
#define F(x, y, z)
TFitResultPtr Fit(FitObject *h1, TF1 *f1, Foption_t &option, const ROOT::Math::MinimizerOptions &moption, const char *goption, ROOT::Fit::DataRange &range)
Definition HFitImpl.cxx:133
Namespace for new Math classes and functions.
auto GetTheRightOp(T(F::*opPtr)(const T *, const double *)) -> decltype(opPtr)
Internal class used by TF1 to get the right operator() signature from a Functor with several ones.
Definition TF1.h:207
ParamFunctorTempl< double > ParamFunctor
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
Double_t Double_v
Definition Types.h:55
Bool_t IsNaN(Double_t x)
Definition TMath.h:892
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
Definition TMath.h:902
Double_t SignalingNaN()
Returns a signaling NaN as defined by IEEE 754](http://en.wikipedia.org/wiki/NaN#Signaling_NaN).
Definition TMath.h:910
Internal class used by TF1 for obtaining the type from a functor out of the set of valid operator() s...
Definition TF1.h:181
static void Build(TF1 *f, const char *formula)
Definition TF1.h:776
Internal class used by TF1 for defining template specialization for different TF1 constructors
Definition TF1.h:169
static void Build(TF1 *f, Func func)
Definition TF1.h:755
TF1FunctorPointer * Clone() const override
Definition TF1.h:317
ROOT::Math::ParamFunctorTempl< T > fImpl
Definition TF1.h:318
TF1FunctorPointerImpl(const std::function< T(const T *f, const Double_t *param)> &func)
Definition TF1.h:315
~TF1FunctorPointerImpl() override
Definition TF1.h:316
TF1FunctorPointerImpl(const ROOT::Math::ParamFunctorTempl< T > &func)
Definition TF1.h:314
virtual ~TF1FunctorPointer()
Definition TF1.h:248
virtual TF1FunctorPointer * Clone() const =0
th1 Draw()