Logo ROOT  
Reference Guide
TMath.h
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/07/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2004, 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
12#ifndef ROOT_TMath
13#define ROOT_TMath
14
15#include "TMathBase.h"
16
17#include "TError.h"
18#include <algorithm>
19#include <limits>
20#include <cmath>
21
22////////////////////////////////////////////////////////////////////////////////
23///
24/// TMath
25///
26/// Encapsulate most frequently used Math functions.
27/// NB. The basic functions Min, Max, Abs and Sign are defined
28/// in TMathBase.
29
30namespace TMath {
31
32////////////////////////////////////////////////////////////////////////////////
33// Fundamental constants
34
35////////////////////////////////////////////////////////////////////////////////
36/// \f$ \pi\f$
37constexpr Double_t Pi()
38{
39 return 3.14159265358979323846;
40}
41
42////////////////////////////////////////////////////////////////////////////////
43/// \f$ 2\pi\f$
44constexpr Double_t TwoPi()
45{
46 return 2.0 * Pi();
47}
48
49////////////////////////////////////////////////////////////////////////////////
50/// \f$ \frac{\pi}{2} \f$
51constexpr Double_t PiOver2()
52{
53 return Pi() / 2.0;
54}
55
56////////////////////////////////////////////////////////////////////////////////
57/// \f$ \frac{\pi}{4} \f$
58constexpr Double_t PiOver4()
59{
60 return Pi() / 4.0;
61}
62
63////////////////////////////////////////////////////////////////////////////////
64/// \f$ \frac{1.}{\pi}\f$
65constexpr Double_t InvPi()
66{
67 return 1.0 / Pi();
68}
69
70////////////////////////////////////////////////////////////////////////////////
71/// Conversion from radian to degree: \f$ \frac{180}{\pi} \f$
72constexpr Double_t RadToDeg()
73{
74 return 180.0 / Pi();
75}
76
77////////////////////////////////////////////////////////////////////////////////
78/// Conversion from degree to radian: \f$ \frac{\pi}{180} \f$
79constexpr Double_t DegToRad()
80{
81 return Pi() / 180.0;
82}
83
84////////////////////////////////////////////////////////////////////////////////
85/// \f$ \sqrt{2} \f$
86constexpr Double_t Sqrt2()
87{
88 return 1.4142135623730950488016887242097;
89}
90
91////////////////////////////////////////////////////////////////////////////////
92/// Base of natural log: \f$ e \f$
93constexpr Double_t E()
94{
95 return 2.71828182845904523536;
96}
97
98////////////////////////////////////////////////////////////////////////////////
99/// Natural log of 10 (to convert log to ln)
100constexpr Double_t Ln10()
101{
102 return 2.30258509299404568402;
103}
104
105////////////////////////////////////////////////////////////////////////////////
106/// Base-10 log of e (to convert ln to log)
107constexpr Double_t LogE()
108{
109 return 0.43429448190325182765;
110}
111
112////////////////////////////////////////////////////////////////////////////////
113/// Velocity of light in \f$ m s^{-1} \f$
114constexpr Double_t C()
115{
116 return 2.99792458e8;
117}
118
119////////////////////////////////////////////////////////////////////////////////
120/// \f$ cm s^{-1} \f$
121constexpr Double_t Ccgs()
122{
123 return 100.0 * C();
124}
125
126////////////////////////////////////////////////////////////////////////////////
127/// Speed of light uncertainty.
129{
130 return 0.0;
131}
132
133////////////////////////////////////////////////////////////////////////////////
134/// Gravitational constant in: \f$ m^{3} kg^{-1} s^{-2} \f$
135constexpr Double_t G()
136{
137 // use 2018 value from NIST (https://physics.nist.gov/cgi-bin/cuu/Value?bg|search_for=G)
138 return 6.67430e-11;
139}
140
141////////////////////////////////////////////////////////////////////////////////
142/// \f$ cm^{3} g^{-1} s^{-2} \f$
143constexpr Double_t Gcgs()
144{
145 return G() * 1000.0;
146}
147
148////////////////////////////////////////////////////////////////////////////////
149/// Gravitational constant uncertainty.
151{
152 // use 2018 value from NIST
153 return 0.00015e-11;
154}
155
156////////////////////////////////////////////////////////////////////////////////
157/// \f$ \frac{G}{\hbar C} \f$ in \f$ (GeV/c^{2})^{-2} \f$
158constexpr Double_t GhbarC()
159{
160 // use new value from NIST (2018)
161 return 6.70883e-39;
162}
163
164////////////////////////////////////////////////////////////////////////////////
165/// \f$ \frac{G}{\hbar C} \f$ uncertainty.
167{
168 // use new value from NIST (2018)
169 return 0.00015e-39;
170}
171
172////////////////////////////////////////////////////////////////////////////////
173/// Standard acceleration of gravity in \f$ m s^{-2} \f$
174constexpr Double_t Gn()
175{
176 return 9.80665;
177}
178
179////////////////////////////////////////////////////////////////////////////////
180/// Standard acceleration of gravity uncertainty.
182{
183 return 0.0;
184}
185
186////////////////////////////////////////////////////////////////////////////////
187/// Planck's constant in \f$ J s \f$: \f$ h \f$
188constexpr Double_t H()
189{
190 return 6.62607015e-34;
191}
192
193////////////////////////////////////////////////////////////////////////////////
194/// \f$ erg s \f$
195constexpr Double_t Hcgs()
196{
197 return 1.0e7 * H();
198}
199
200////////////////////////////////////////////////////////////////////////////////
201/// Planck's constant uncertainty.
203{
204 // Planck constant is exact according to 2019 redefinition
205 // (https://en.wikipedia.org/wiki/2019_redefinition_of_the_SI_base_units)
206 return 0.0;
207}
208
209////////////////////////////////////////////////////////////////////////////////
210/// \f$ \hbar \f$ in \f$ J s \f$: \f$ \hbar = \frac{h}{2\pi} \f$
211constexpr Double_t Hbar()
212{
213 return 1.054571817e-34;
214}
215
216////////////////////////////////////////////////////////////////////////////////
217/// \f$ erg s \f$
218constexpr Double_t Hbarcgs()
219{
220 return 1.0e7 * Hbar();
221}
222
223////////////////////////////////////////////////////////////////////////////////
224/// \f$ \hbar \f$ uncertainty.
226{
227 // hbar is an exact constant
228 return 0.0;
229}
230
231////////////////////////////////////////////////////////////////////////////////
232/// \f$ hc \f$ in \f$ J m \f$
233constexpr Double_t HC()
234{
235 return H() * C();
236}
237
238////////////////////////////////////////////////////////////////////////////////
239/// \f$ erg cm \f$
240constexpr Double_t HCcgs()
241{
242 return Hcgs() * Ccgs();
243}
244
245////////////////////////////////////////////////////////////////////////////////
246/// Boltzmann's constant in \f$ J K^{-1} \f$: \f$ k \f$
247constexpr Double_t K()
248{
249 return 1.380649e-23;
250}
251
252////////////////////////////////////////////////////////////////////////////////
253/// \f$ erg K^{-1} \f$
254constexpr Double_t Kcgs()
255{
256 return 1.0e7 * K();
257}
258
259////////////////////////////////////////////////////////////////////////////////
260/// Boltzmann's constant uncertainty.
262{
263 // constant is exact according to 2019 redefinition
264 // (https://en.wikipedia.org/wiki/2019_redefinition_of_the_SI_base_units)
265 return 0.0;
266}
267
268////////////////////////////////////////////////////////////////////////////////
269/// Stefan-Boltzmann constant in \f$ W m^{-2} K^{-4}\f$: \f$ \sigma \f$
270constexpr Double_t Sigma()
271{
272 return 5.670373e-8;
273}
274
275////////////////////////////////////////////////////////////////////////////////
276/// Stefan-Boltzmann constant uncertainty.
278{
279 return 0.0;
280}
281
282////////////////////////////////////////////////////////////////////////////////
283/// Avogadro constant (Avogadro's Number) in \f$ mol^{-1} \f$
284constexpr Double_t Na()
285{
286 return 6.02214076e+23;
287}
288
289////////////////////////////////////////////////////////////////////////////////
290/// Avogadro constant (Avogadro's Number) uncertainty.
292{
293 // constant is exact according to 2019 redefinition
294 // (https://en.wikipedia.org/wiki/2019_redefinition_of_the_SI_base_units)
295 return 0.0;
296}
297
298////////////////////////////////////////////////////////////////////////////////
299/// [Universal gas constant](http://scienceworld.wolfram.com/physics/UniversalGasConstant.html)
300/// (\f$ Na K \f$) in \f$ J K^{-1} mol^{-1} \f$
301//
302constexpr Double_t R()
303{
304 return K() * Na();
305}
306
307////////////////////////////////////////////////////////////////////////////////
308/// Universal gas constant uncertainty.
310{
311 return R() * ((KUncertainty() / K()) + (NaUncertainty() / Na()));
312}
313
314////////////////////////////////////////////////////////////////////////////////
315/// [Molecular weight of dry air 1976 US Standard Atmosphere](http://atmos.nmsu.edu/jsdap/encyclopediawork.html)
316/// in \f$ kg kmol^{-1} \f$ or \f$ gm mol^{-1} \f$
317constexpr Double_t MWair()
318{
319 return 28.9644;
320}
321
322////////////////////////////////////////////////////////////////////////////////
323/// [Dry Air Gas Constant (R / MWair)](http://atmos.nmsu.edu/education_and_outreach/encyclopedia/gas_constant.htm)
324/// in \f$ J kg^{-1} K^{-1} \f$
325constexpr Double_t Rgair()
326{
327 return (1000.0 * R()) / MWair();
328}
329
330////////////////////////////////////////////////////////////////////////////////
331/// Euler-Mascheroni Constant.
333{
334 return 0.577215664901532860606512090082402431042;
335}
336
337////////////////////////////////////////////////////////////////////////////////
338/// Elementary charge in \f$ C \f$ .
339constexpr Double_t Qe()
340{
341 return 1.602176634e-19;
342}
343
344////////////////////////////////////////////////////////////////////////////////
345/// Elementary charge uncertainty.
347{
348 // constant is exact according to 2019 redefinition
349 // (https://en.wikipedia.org/wiki/2019_redefinition_of_the_SI_base_units)
350 return 0.0;
351}
352
353////////////////////////////////////////////////////////////////////////////////
354// Mathematical Functions
355
356////////////////////////////////////////////////////////////////////////////////
357// Trigonometrical Functions
358
359inline Double_t Sin(Double_t);
360inline Double_t Cos(Double_t);
361inline Double_t Tan(Double_t);
362inline Double_t SinH(Double_t);
363inline Double_t CosH(Double_t);
364inline Double_t TanH(Double_t);
365inline Double_t ASin(Double_t);
366inline Double_t ACos(Double_t);
367inline Double_t ATan(Double_t);
373
374////////////////////////////////////////////////////////////////////////////////
375// Elementary Functions
376
377inline Double_t Ceil(Double_t x);
378inline Int_t CeilNint(Double_t x);
379inline Double_t Floor(Double_t x);
380inline Int_t FloorNint(Double_t x);
381template <typename T>
382inline Int_t Nint(T x);
383
384inline Double_t Sq(Double_t x);
385inline Double_t Sqrt(Double_t x);
386inline Double_t Exp(Double_t x);
393inline Double_t Power(Double_t x, Int_t y);
394inline Double_t Log(Double_t x);
396inline Double_t Log10(Double_t x);
397inline Int_t Finite(Double_t x);
398inline Int_t Finite(Float_t x);
399inline Bool_t IsNaN(Double_t x);
400inline Bool_t IsNaN(Float_t x);
401
402inline Double_t QuietNaN();
403inline Double_t SignalingNaN();
404inline Double_t Infinity();
405
406template <typename T>
407struct Limits {
408 inline static T Min();
409 inline static T Max();
410 inline static T Epsilon();
411 };
412
413 // Some integer math
415
416 /// Comparing floating points.
417 /// Returns `kTRUE` if the absolute difference between `af` and `bf` is less than `epsilon`.
419 return TMath::Abs(af-bf) < epsilon ||
420 TMath::Abs(af - bf) < Limits<Double_t>::Min(); // handle 0 < 0 case
421
422 }
423 /// Comparing floating points.
424 /// Returns `kTRUE` if the relative difference between `af` and `bf` is less than `relPrec`.
425 inline Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec) {
426 return TMath::Abs(af - bf) <= 0.5 * relPrec * (TMath::Abs(af) + TMath::Abs(bf)) ||
427 TMath::Abs(af - bf) < Limits<Double_t>::Min(); // handle denormals
428 }
429
430 /////////////////////////////////////////////////////////////////////////////
431 // Array Algorithms
432
433 // Min, Max of an array
434 template <typename T> T MinElement(Long64_t n, const T *a);
435 template <typename T> T MaxElement(Long64_t n, const T *a);
436
437 // Locate Min, Max element number in an array
438 template <typename T> Long64_t LocMin(Long64_t n, const T *a);
439 template <typename Iterator> Iterator LocMin(Iterator first, Iterator last);
440 template <typename T> Long64_t LocMax(Long64_t n, const T *a);
441 template <typename Iterator> Iterator LocMax(Iterator first, Iterator last);
442
443 // Hashing
444 ULong_t Hash(const void *txt, Int_t ntxt);
445 ULong_t Hash(const char *str);
446
447 void BubbleHigh(Int_t Narr, Double_t *arr1, Int_t *arr2);
448 void BubbleLow (Int_t Narr, Double_t *arr1, Int_t *arr2);
449
450 Bool_t Permute(Int_t n, Int_t *a); // Find permutations
451
452 /////////////////////////////////////////////////////////////////////////////
453 // Geometrical Functions
454
455 //Sample quantiles
456 void Quantiles(Int_t n, Int_t nprob, Double_t *x, Double_t *quantiles, Double_t *prob,
457 Bool_t isSorted=kTRUE, Int_t *index = nullptr, Int_t type=7);
458
459 // IsInside
460 template <typename T> Bool_t IsInside(T xp, T yp, Int_t np, T *x, T *y);
461
462 // Calculate the Cross Product of two vectors
463 template <typename T> T *Cross(const T v1[3],const T v2[3], T out[3]);
464
465 Float_t Normalize(Float_t v[3]); // Normalize a vector
466 Double_t Normalize(Double_t v[3]); // Normalize a vector
467
468 //Calculate the Normalized Cross Product of two vectors
469 template <typename T> inline T NormCross(const T v1[3],const T v2[3],T out[3]);
470
471 // Calculate a normal vector of a plane
472 template <typename T> T *Normal2Plane(const T v1[3],const T v2[3],const T v3[3], T normal[3]);
473
474 /////////////////////////////////////////////////////////////////////////////
475 // Polynomial Functions
476
477 Bool_t RootsCubic(const Double_t coef[4],Double_t &a, Double_t &b, Double_t &c);
478
479 /////////////////////////////////////////////////////////////////////////////
480 // Statistic Functions
481
482 Double_t Binomial(Int_t n,Int_t k); // Calculate the binomial coefficient n over k
501 Double_t Prob(Double_t chi2,Int_t ndf);
508
509 /////////////////////////////////////////////////////////////////////////////
510 // Statistics over arrays
511
512 //Mean, Geometric Mean, Median, RMS(sigma)
513
514 template <typename T> Double_t Mean(Long64_t n, const T *a, const Double_t *w=0);
515 template <typename Iterator> Double_t Mean(Iterator first, Iterator last);
516 template <typename Iterator, typename WeightIterator> Double_t Mean(Iterator first, Iterator last, WeightIterator wfirst);
517
518 template <typename T> Double_t GeomMean(Long64_t n, const T *a);
519 template <typename Iterator> Double_t GeomMean(Iterator first, Iterator last);
520
521 template <typename T> Double_t RMS(Long64_t n, const T *a, const Double_t *w=0);
522 template <typename Iterator> Double_t RMS(Iterator first, Iterator last);
523 template <typename Iterator, typename WeightIterator> Double_t RMS(Iterator first, Iterator last, WeightIterator wfirst);
524
525 template <typename T> Double_t StdDev(Long64_t n, const T *a, const Double_t * w = 0) { return RMS<T>(n,a,w); } /// Same as RMS
526 template <typename Iterator> Double_t StdDev(Iterator first, Iterator last) { return RMS<Iterator>(first,last); } /// Same as RMS
527 template <typename Iterator, typename WeightIterator> Double_t StdDev(Iterator first, Iterator last, WeightIterator wfirst) { return RMS<Iterator,WeightIterator>(first,last,wfirst); } /// Same as RMS
528
529 template <typename T> Double_t Median(Long64_t n, const T *a, const Double_t *w=0, Long64_t *work=0);
530
531 //k-th order statistic
532 template <class Element, typename Size> Element KOrdStat(Size n, const Element *a, Size k, Size *work = 0);
533
534 /////////////////////////////////////////////////////////////////////////////
535 // Special Functions
536
542
543 // Bessel functions
544 Double_t BesselI(Int_t n,Double_t x); /// Integer order modified Bessel function I_n(x)
545 Double_t BesselK(Int_t n,Double_t x); /// Integer order modified Bessel function K_n(x)
546 Double_t BesselI0(Double_t x); /// Modified Bessel function I_0(x)
547 Double_t BesselK0(Double_t x); /// Modified Bessel function K_0(x)
548 Double_t BesselI1(Double_t x); /// Modified Bessel function I_1(x)
549 Double_t BesselK1(Double_t x); /// Modified Bessel function K_1(x)
550 Double_t BesselJ0(Double_t x); /// Bessel function J0(x) for any real x
551 Double_t BesselJ1(Double_t x); /// Bessel function J1(x) for any real x
552 Double_t BesselY0(Double_t x); /// Bessel function Y0(x) for positive x
553 Double_t BesselY1(Double_t x); /// Bessel function Y1(x) for positive x
554 Double_t StruveH0(Double_t x); /// Struve functions of order 0
555 Double_t StruveH1(Double_t x); /// Struve functions of order 1
556 Double_t StruveL0(Double_t x); /// Modified Struve functions of order 0
557 Double_t StruveL1(Double_t x); /// Modified Struve functions of order 1
558
569}
570
571////////////////////////////////////////////////////////////////////////////////
572// Trig and other functions
573
574#include <float.h>
575#include <math.h>
576
577#if defined(R__WIN32) && !defined(__CINT__)
578# ifndef finite
579# define finite _finite
580# endif
581#endif
582
583////////////////////////////////////////////////////////////////////////////////
584/// Returns the sine of an angle of `x` radians.
585
587 { return sin(x); }
588
589////////////////////////////////////////////////////////////////////////////////
590/// Returns the cosine of an angle of `x` radians.
591
593 { return cos(x); }
594
595////////////////////////////////////////////////////////////////////////////////
596/// Returns the tangent of an angle of `x` radians.
597
599 { return tan(x); }
600
601////////////////////////////////////////////////////////////////////////////////
602/// Returns the hyperbolic sine of `x.
603
605 { return sinh(x); }
606
607////////////////////////////////////////////////////////////////////////////////
608/// Returns the hyperbolic cosine of `x`.
609
611 { return cosh(x); }
612
613////////////////////////////////////////////////////////////////////////////////
614/// Returns the hyperbolic tangent of `x`.
615
617 { return tanh(x); }
618
619////////////////////////////////////////////////////////////////////////////////
620/// Returns the principal value of the arc sine of `x`, expressed in radians.
621
623 {
624 return asin(x);
625 }
626
627////////////////////////////////////////////////////////////////////////////////
628/// Returns the principal value of the arc cosine of `x`, expressed in radians.
629
631 {
632 return acos(x);
633 }
634
635////////////////////////////////////////////////////////////////////////////////
636/// Returns the principal value of the arc tangent of `x`, expressed in radians.
637
639 { return atan(x); }
640
641////////////////////////////////////////////////////////////////////////////////
642/// Returns the principal value of the arc tangent of `y/x`, expressed in radians.
643
645 { if (x != 0) return atan2(y, x);
646 if (y == 0) return 0;
647 if (y > 0) return Pi()/2;
648 else return -Pi()/2;
649 }
650
651////////////////////////////////////////////////////////////////////////////////
652/// Returns `x*x`.
653
655 { return x*x; }
656
657////////////////////////////////////////////////////////////////////////////////
658/// Returns the square root of x.
659
661 { return sqrt(x); }
662
663////////////////////////////////////////////////////////////////////////////////
664/// Rounds `x` upward, returning the smallest integral value that is not less than `x`.
665
667 { return ceil(x); }
668
669////////////////////////////////////////////////////////////////////////////////
670/// Returns the nearest integer of `TMath::Ceil(x)`.
671
673 { return TMath::Nint(ceil(x)); }
674
675////////////////////////////////////////////////////////////////////////////////
676/// Rounds `x` downward, returning the largest integral value that is not greater than `x`.
677
679 { return floor(x); }
680
681////////////////////////////////////////////////////////////////////////////////
682/// Returns the nearest integer of `TMath::Floor(x)`.
683
685 { return TMath::Nint(floor(x)); }
686
687////////////////////////////////////////////////////////////////////////////////
688/// Round to nearest integer. Rounds half integers to the nearest even integer.
689
690template<typename T>
692{
693 int i;
694 if (x >= 0) {
695 i = int(x + 0.5);
696 if ( i & 1 && x + 0.5 == T(i) ) i--;
697 } else {
698 i = int(x - 0.5);
699 if ( i & 1 && x - 0.5 == T(i) ) i++;
700 }
701 return i;
702}
703
704////////////////////////////////////////////////////////////////////////////////
705/// Returns the base-e exponential function of x, which is e raised to the power `x`.
706
708 { return exp(x); }
709
710////////////////////////////////////////////////////////////////////////////////
711/// Returns the result of multiplying `x` (the significant) by 2 raised to the power of `exp` (the exponent).
712
714 { return ldexp(x, exp); }
715
716////////////////////////////////////////////////////////////////////////////////
717/// Returns `x` raised to the power `y`.
718
720 { return std::pow(x,y); }
721
722////////////////////////////////////////////////////////////////////////////////
723/// Returns `x` raised to the power `y`.
724
726 { return std::pow(x,(LongDouble_t)y); }
727
728////////////////////////////////////////////////////////////////////////////////
729/// Returns `x` raised to the power `y`.
730
732 { return std::pow(x,y); }
733
734////////////////////////////////////////////////////////////////////////////////
735/// Returns `x` raised to the power `y`.
736
738 { return pow(x, y); }
739
740////////////////////////////////////////////////////////////////////////////////
741/// Returns `x` raised to the power `y`.
742
744#ifdef R__ANSISTREAM
745 return std::pow(x, y);
746#else
747 return pow(x, (Double_t) y);
748#endif
749}
750
751////////////////////////////////////////////////////////////////////////////////
752/// Returns the natural logarithm of `x`.
753
755 { return log(x); }
756
757////////////////////////////////////////////////////////////////////////////////
758/// Returns the common (base-10) logarithm of `x`.
759
761 { return log10(x); }
762
763////////////////////////////////////////////////////////////////////////////////
764/// Check if it is finite with a mask in order to be consistent in presence of
765/// fast math.
766/// Inspired from the CMSSW FWCore/Utilities package
767
769#if defined(R__FAST_MATH)
770
771{
772 const unsigned long long mask = 0x7FF0000000000000LL;
773 union { unsigned long long l; double d;} v;
774 v.d =x;
775 return (v.l&mask)!=mask;
776}
777#else
778# if defined(R__HPUX11)
779 { return isfinite(x); }
780# elif defined(R__MACOSX)
781# ifdef isfinite
782 // from math.h
783 { return isfinite(x); }
784# else
785 // from cmath
786 { return std::isfinite(x); }
787# endif
788# else
789 { return finite(x); }
790# endif
791#endif
792
793////////////////////////////////////////////////////////////////////////////////
794/// Check if it is finite with a mask in order to be consistent in presence of
795/// fast math.
796/// Inspired from the CMSSW FWCore/Utilities package
797
799#if defined(R__FAST_MATH)
800
801{
802 const unsigned int mask = 0x7f800000;
803 union { unsigned int l; float d;} v;
804 v.d =x;
805 return (v.l&mask)!=mask;
806}
807#else
808{ return std::isfinite(x); }
809#endif
810
811// This namespace provides all the routines necessary for checking if a number
812// is a NaN also in presence of optimisations affecting the behaviour of the
813// floating point calculations.
814// Inspired from the CMSSW FWCore/Utilities package
815
816#if defined (R__FAST_MATH)
817namespace ROOT {
818namespace Internal {
819namespace Math {
820// abridged from GNU libc 2.6.1 - in detail from
821// math/math_private.h
822// sysdeps/ieee754/ldbl-96/math_ldbl.h
823
824// part of ths file:
825 /*
826 * ====================================================
827 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
828 *
829 * Developed at SunPro, a Sun Microsystems, Inc. business.
830 * Permission to use, copy, modify, and distribute this
831 * software is freely granted, provided that this notice
832 * is preserved.
833 * ====================================================
834 */
835
836 // A union which permits us to convert between a double and two 32 bit ints.
837 typedef union {
839 struct {
840 UInt_t lsw;
841 UInt_t msw;
842 } parts;
843 } ieee_double_shape_type;
844
845#define EXTRACT_WORDS(ix0,ix1,d) \
846 do { \
847 ieee_double_shape_type ew_u; \
848 ew_u.value = (d); \
849 (ix0) = ew_u.parts.msw; \
850 (ix1) = ew_u.parts.lsw; \
851 } while (0)
852
853 inline Bool_t IsNaN(Double_t x)
854 {
855 UInt_t hx, lx;
856
857 EXTRACT_WORDS(hx, lx, x);
858
859 lx |= hx & 0xfffff;
860 hx &= 0x7ff00000;
861 return (hx == 0x7ff00000) && (lx != 0);
862 }
863
864 typedef union {
866 UInt_t word;
867 } ieee_float_shape_type;
868
869#define GET_FLOAT_WORD(i,d) \
870 do { \
871 ieee_float_shape_type gf_u; \
872 gf_u.value = (d); \
873 (i) = gf_u.word; \
874 } while (0)
875
876 inline Bool_t IsNaN(Float_t x)
877 {
878 UInt_t wx;
879 GET_FLOAT_WORD (wx, x);
880 wx &= 0x7fffffff;
881 return (Bool_t)(wx > 0x7f800000);
882 }
883} } } // end NS ROOT::Internal::Math
884#endif // End R__FAST_MATH
885
886#if defined(R__FAST_MATH)
889#else
890 inline Bool_t TMath::IsNaN(Double_t x) { return std::isnan(x); }
891 inline Bool_t TMath::IsNaN(Float_t x) { return std::isnan(x); }
892#endif
893
894////////////////////////////////////////////////////////////////////////////////
895// Wrapper to numeric_limits
896
897////////////////////////////////////////////////////////////////////////////////
898/// Returns a quiet NaN as [defined by IEEE 754](http://en.wikipedia.org/wiki/NaN#Quiet_NaN).
899
901
902 return std::numeric_limits<Double_t>::quiet_NaN();
903}
904
905////////////////////////////////////////////////////////////////////////////////
906/// Returns a signaling NaN as defined by IEEE 754](http://en.wikipedia.org/wiki/NaN#Signaling_NaN).
907
909 return std::numeric_limits<Double_t>::signaling_NaN();
910}
911
912////////////////////////////////////////////////////////////////////////////////
913/// Returns an infinity as defined by the IEEE standard.
914
916 return std::numeric_limits<Double_t>::infinity();
917}
918
919////////////////////////////////////////////////////////////////////////////////
920/// Returns maximum representation for type T.
921
922template<typename T>
924 return (std::numeric_limits<T>::min)(); //N.B. use this signature to avoid class with macro min() on Windows
925}
926
927////////////////////////////////////////////////////////////////////////////////
928/// Returns minimum double representation.
929
930template<typename T>
932 return (std::numeric_limits<T>::max)(); //N.B. use this signature to avoid class with macro max() on Windows
933}
934
935////////////////////////////////////////////////////////////////////////////////
936/// Returns minimum double representation.
937
938template<typename T>
941}
942
943////////////////////////////////////////////////////////////////////////////////
944// Advanced.
945
946////////////////////////////////////////////////////////////////////////////////
947/// Calculates the Normalized Cross Product of two vectors.
948
949template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3],T out[3])
950{
951 return Normalize(Cross(v1,v2,out));
952}
953
954////////////////////////////////////////////////////////////////////////////////
955/// Returns minimum of array a of length n.
956
957template <typename T>
959 return *std::min_element(a,a+n);
960}
961
962////////////////////////////////////////////////////////////////////////////////
963/// Returns maximum of array a of length n.
964
965template <typename T>
967 return *std::max_element(a,a+n);
968}
969
970////////////////////////////////////////////////////////////////////////////////
971/// Returns index of array with the minimum element.
972/// If more than one element is minimum returns first found.
973///
974/// Implement here since this one is found to be faster (mainly on 64 bit machines)
975/// than stl generic implementation.
976/// When performing the comparison, the STL implementation needs to de-reference both the array iterator
977/// and the iterator pointing to the resulting minimum location
978
979template <typename T>
981 if (n <= 0 || !a) return -1;
982 T xmin = a[0];
983 Long64_t loc = 0;
984 for (Long64_t i = 1; i < n; i++) {
985 if (xmin > a[i]) {
986 xmin = a[i];
987 loc = i;
988 }
989 }
990 return loc;
991}
992
993////////////////////////////////////////////////////////////////////////////////
994/// Returns index of array with the minimum element.
995/// If more than one element is minimum returns first found.
996
997template <typename Iterator>
998Iterator TMath::LocMin(Iterator first, Iterator last) {
999
1000 return std::min_element(first, last);
1001}
1002
1003////////////////////////////////////////////////////////////////////////////////
1004/// Returns index of array with the maximum element.
1005/// If more than one element is maximum returns first found.
1006///
1007/// Implement here since it is faster (see comment in LocMin function)
1008
1009template <typename T>
1011 if (n <= 0 || !a) return -1;
1012 T xmax = a[0];
1013 Long64_t loc = 0;
1014 for (Long64_t i = 1; i < n; i++) {
1015 if (xmax < a[i]) {
1016 xmax = a[i];
1017 loc = i;
1018 }
1019 }
1020 return loc;
1021}
1022
1023////////////////////////////////////////////////////////////////////////////////
1024/// Returns index of array with the maximum element.
1025/// If more than one element is maximum returns first found.
1026
1027template <typename Iterator>
1028Iterator TMath::LocMax(Iterator first, Iterator last)
1029{
1030
1031 return std::max_element(first, last);
1032}
1033
1034////////////////////////////////////////////////////////////////////////////////
1035/// Returns the weighted mean of an array defined by the iterators.
1036
1037template <typename Iterator>
1038Double_t TMath::Mean(Iterator first, Iterator last)
1039{
1040 Double_t sum = 0;
1041 Double_t sumw = 0;
1042 while ( first != last )
1043 {
1044 sum += *first;
1045 sumw += 1;
1046 first++;
1047 }
1048
1049 return sum/sumw;
1050}
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// Returns the weighted mean of an array defined by the first and
1054/// last iterators. The w iterator should point to the first element
1055/// of a vector of weights of the same size as the main array.
1056
1057template <typename Iterator, typename WeightIterator>
1058Double_t TMath::Mean(Iterator first, Iterator last, WeightIterator w)
1059{
1060
1061 Double_t sum = 0;
1062 Double_t sumw = 0;
1063 int i = 0;
1064 while ( first != last ) {
1065 if ( *w < 0) {
1066 ::Error("TMath::Mean","w[%d] = %.4e < 0 ?!",i,*w);
1067 return 0;
1068 }
1069 sum += (*w) * (*first);
1070 sumw += (*w) ;
1071 ++w;
1072 ++first;
1073 ++i;
1074 }
1075 if (sumw <= 0) {
1076 ::Error("TMath::Mean","sum of weights == 0 ?!");
1077 return 0;
1078 }
1079
1080 return sum/sumw;
1081}
1082
1083////////////////////////////////////////////////////////////////////////////////
1084/// Returns the weighted mean of an array a with length n.
1085
1086template <typename T>
1088{
1089 if (w) {
1090 return TMath::Mean(a, a+n, w);
1091 } else {
1092 return TMath::Mean(a, a+n);
1093 }
1094}
1095
1096////////////////////////////////////////////////////////////////////////////////
1097/// Returns the geometric mean of an array defined by the iterators.
1098/// \f[ GeomMean = (\prod_{i=0}^{n-1} |a[i]|)^{1/n} \f]
1099
1100template <typename Iterator>
1101Double_t TMath::GeomMean(Iterator first, Iterator last)
1102{
1103 Double_t logsum = 0.;
1104 Long64_t n = 0;
1105 while ( first != last ) {
1106 if (*first == 0) return 0.;
1107 Double_t absa = (Double_t) TMath::Abs(*first);
1108 logsum += TMath::Log(absa);
1109 ++first;
1110 ++n;
1111 }
1112
1113 return TMath::Exp(logsum/n);
1114}
1115
1116////////////////////////////////////////////////////////////////////////////////
1117/// Returns the geometric mean of an array a of size n.
1118/// \f[ GeomMean = (\prod_{i=0}^{n-1} |a[i]|)^{1/n} \f]
1119
1120template <typename T>
1122{
1123 return TMath::GeomMean(a, a+n);
1124}
1125
1126////////////////////////////////////////////////////////////////////////////////
1127/// Returns the Standard Deviation of an array defined by the iterators.
1128/// Note that this function returns the sigma(standard deviation) and
1129/// not the root mean square of the array.
1130///
1131/// Use the two pass algorithm, which is slower (! a factor of 2) but much more
1132/// precise. Since we have a vector the 2 pass algorithm is still faster than the
1133/// Welford algorithm. (See also ROOT-5545)
1134
1135template <typename Iterator>
1136Double_t TMath::RMS(Iterator first, Iterator last)
1137{
1138
1139 Double_t n = 0;
1140
1141 Double_t tot = 0;
1142 Double_t mean = TMath::Mean(first,last);
1143 while ( first != last ) {
1145 tot += (x - mean)*(x - mean);
1146 ++first;
1147 ++n;
1148 }
1149 Double_t rms = (n > 1) ? TMath::Sqrt(tot/(n-1)) : 0.0;
1150 return rms;
1151}
1152
1153////////////////////////////////////////////////////////////////////////////////
1154/// Returns the weighted Standard Deviation of an array defined by the iterators.
1155/// Note that this function returns the sigma(standard deviation) and
1156/// not the root mean square of the array.
1157///
1158/// As in the unweighted case use the two pass algorithm
1159
1160template <typename Iterator, typename WeightIterator>
1161Double_t TMath::RMS(Iterator first, Iterator last, WeightIterator w)
1162{
1163 Double_t tot = 0;
1164 Double_t sumw = 0;
1165 Double_t sumw2 = 0;
1166 Double_t mean = TMath::Mean(first,last,w);
1167 while ( first != last ) {
1169 sumw += *w;
1170 sumw2 += (*w) * (*w);
1171 tot += (*w) * (x - mean)*(x - mean);
1172 ++first;
1173 ++w;
1174 }
1175 // use the correction neff/(neff -1) for the unbiased formula
1176 Double_t rms = TMath::Sqrt(tot * sumw/ (sumw*sumw - sumw2) );
1177 return rms;
1178}
1179
1180////////////////////////////////////////////////////////////////////////////////
1181/// Returns the Standard Deviation of an array a with length n.
1182/// Note that this function returns the sigma(standard deviation) and
1183/// not the root mean square of the array.
1184
1185template <typename T>
1187{
1188 return (w) ? TMath::RMS(a, a+n, w) : TMath::RMS(a, a+n);
1189}
1190
1191////////////////////////////////////////////////////////////////////////////////
1192/// Calculates the Cross Product of two vectors:
1193/// out = [v1 x v2]
1194
1195template <typename T> T *TMath::Cross(const T v1[3],const T v2[3], T out[3])
1196{
1197 out[0] = v1[1] * v2[2] - v1[2] * v2[1];
1198 out[1] = v1[2] * v2[0] - v1[0] * v2[2];
1199 out[2] = v1[0] * v2[1] - v1[1] * v2[0];
1200
1201 return out;
1202}
1203
1204////////////////////////////////////////////////////////////////////////////////
1205/// Calculates a normal vector of a plane.
1206///
1207/// \param[in] p1, p2,p3 3 3D points belonged the plane to define it.
1208/// \param[out] normal Pointer to 3D normal vector (normalized)
1209
1210template <typename T> T * TMath::Normal2Plane(const T p1[3],const T p2[3],const T p3[3], T normal[3])
1211{
1212 T v1[3], v2[3];
1213
1214 v1[0] = p2[0] - p1[0];
1215 v1[1] = p2[1] - p1[1];
1216 v1[2] = p2[2] - p1[2];
1217
1218 v2[0] = p3[0] - p1[0];
1219 v2[1] = p3[1] - p1[1];
1220 v2[2] = p3[2] - p1[2];
1221
1222 NormCross(v1,v2,normal);
1223 return normal;
1224}
1225
1226////////////////////////////////////////////////////////////////////////////////
1227/// Function which returns kTRUE if point xp,yp lies inside the
1228/// polygon defined by the np points in arrays x and y, kFALSE otherwise.
1229/// Note that the polygon may be open or closed.
1230
1231template <typename T> Bool_t TMath::IsInside(T xp, T yp, Int_t np, T *x, T *y)
1232{
1233 Int_t i, j = np-1 ;
1234 Bool_t oddNodes = kFALSE;
1235
1236 for (i=0; i<np; i++) {
1237 if ((y[i]<yp && y[j]>=yp) || (y[j]<yp && y[i]>=yp)) {
1238 if (x[i]+(yp-y[i])/(y[j]-y[i])*(x[j]-x[i])<xp) {
1239 oddNodes = !oddNodes;
1240 }
1241 }
1242 j=i;
1243 }
1244
1245 return oddNodes;
1246}
1247
1248////////////////////////////////////////////////////////////////////////////////
1249/// Returns the median of the array a where each entry i has weight w[i] .
1250/// Both arrays have a length of at least n . The median is a number obtained
1251/// from the sorted array a through
1252///
1253/// median = (a[jl]+a[jh])/2. where (using also the sorted index on the array w)
1254///
1255/// sum_i=0,jl w[i] <= sumTot/2
1256/// sum_i=0,jh w[i] >= sumTot/2
1257/// sumTot = sum_i=0,n w[i]
1258///
1259/// If w=0, the algorithm defaults to the median definition where it is
1260/// a number that divides the sorted sequence into 2 halves.
1261/// When n is odd or n > 1000, the median is kth element k = (n + 1) / 2.
1262/// when n is even and n < 1000the median is a mean of the elements k = n/2 and k = n/2 + 1.
1263///
1264/// If the weights are supplied (w not 0) all weights must be >= 0
1265///
1266/// If work is supplied, it is used to store the sorting index and assumed to be
1267/// >= n . If work=0, local storage is used, either on the stack if n < kWorkMax
1268/// or on the heap for n >= kWorkMax .
1269
1270template <typename T> Double_t TMath::Median(Long64_t n, const T *a, const Double_t *w, Long64_t *work)
1271{
1272
1273 const Int_t kWorkMax = 100;
1274
1275 if (n <= 0 || !a) return 0;
1276 Bool_t isAllocated = kFALSE;
1277 Double_t median;
1278 Long64_t *ind;
1279 Long64_t workLocal[kWorkMax];
1280
1281 if (work) {
1282 ind = work;
1283 } else {
1284 ind = workLocal;
1285 if (n > kWorkMax) {
1286 isAllocated = kTRUE;
1287 ind = new Long64_t[n];
1288 }
1289 }
1290
1291 if (w) {
1292 Double_t sumTot2 = 0;
1293 for (Int_t j = 0; j < n; j++) {
1294 if (w[j] < 0) {
1295 ::Error("TMath::Median","w[%d] = %.4e < 0 ?!",j,w[j]);
1296 if (isAllocated) delete [] ind;
1297 return 0;
1298 }
1299 sumTot2 += w[j];
1300 }
1301
1302 sumTot2 /= 2.;
1303
1304 Sort(n, a, ind, kFALSE);
1305
1306 Double_t sum = 0.;
1307 Int_t jl;
1308 for (jl = 0; jl < n; jl++) {
1309 sum += w[ind[jl]];
1310 if (sum >= sumTot2) break;
1311 }
1312
1313 Int_t jh;
1314 sum = 2.*sumTot2;
1315 for (jh = n-1; jh >= 0; jh--) {
1316 sum -= w[ind[jh]];
1317 if (sum <= sumTot2) break;
1318 }
1319
1320 median = 0.5*(a[ind[jl]]+a[ind[jh]]);
1321
1322 } else {
1323
1324 if (n%2 == 1)
1325 median = KOrdStat(n, a,n/2, ind);
1326 else {
1327 median = 0.5*(KOrdStat(n, a, n/2 -1, ind)+KOrdStat(n, a, n/2, ind));
1328 }
1329 }
1330
1331 if (isAllocated)
1332 delete [] ind;
1333 return median;
1334}
1335
1336////////////////////////////////////////////////////////////////////////////////
1337/// Returns k_th order statistic of the array a of size n
1338/// (k_th smallest element out of n elements).
1339///
1340/// C-convention is used for array indexing, so if you want
1341/// the second smallest element, call KOrdStat(n, a, 1).
1342///
1343/// If work is supplied, it is used to store the sorting index and
1344/// assumed to be >= n. If work=0, local storage is used, either on
1345/// the stack if n < kWorkMax or on the heap for n >= kWorkMax.
1346/// Note that the work index array will not contain the sorted indices but
1347/// all indices of the smaller element in arbitrary order in work[0,...,k-1] and
1348/// all indices of the larger element in arbitrary order in work[k+1,..,n-1]
1349/// work[k] will contain instead the index of the returned element.
1350///
1351/// Taken from "Numerical Recipes in C++" without the index array
1352/// implemented by Anna Khreshuk.
1353///
1354/// See also the declarations at the top of this file
1355
1356template <class Element, typename Size>
1357Element TMath::KOrdStat(Size n, const Element *a, Size k, Size *work)
1358{
1359
1360 const Int_t kWorkMax = 100;
1361
1362 typedef Size Index;
1363
1364 Bool_t isAllocated = kFALSE;
1365 Size i, ir, j, l, mid;
1366 Index arr;
1367 Index *ind;
1368 Index workLocal[kWorkMax];
1369 Index temp;
1370
1371 if (work) {
1372 ind = work;
1373 } else {
1374 ind = workLocal;
1375 if (n > kWorkMax) {
1376 isAllocated = kTRUE;
1377 ind = new Index[n];
1378 }
1379 }
1380
1381 for (Size ii=0; ii<n; ii++) {
1382 ind[ii]=ii;
1383 }
1384 Size rk = k;
1385 l=0;
1386 ir = n-1;
1387 for(;;) {
1388 if (ir<=l+1) { //active partition contains 1 or 2 elements
1389 if (ir == l+1 && a[ind[ir]]<a[ind[l]])
1390 {temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}
1391 Element tmp = a[ind[rk]];
1392 if (isAllocated)
1393 delete [] ind;
1394 return tmp;
1395 } else {
1396 mid = (l+ir) >> 1; //choose median of left, center and right
1397 {temp = ind[mid]; ind[mid]=ind[l+1]; ind[l+1]=temp;}//elements as partitioning element arr.
1398 if (a[ind[l]]>a[ind[ir]]) //also rearrange so that a[l]<=a[l+1]
1399 {temp = ind[l]; ind[l]=ind[ir]; ind[ir]=temp;}
1400
1401 if (a[ind[l+1]]>a[ind[ir]])
1402 {temp=ind[l+1]; ind[l+1]=ind[ir]; ind[ir]=temp;}
1403
1404 if (a[ind[l]]>a[ind[l+1]])
1405 {temp = ind[l]; ind[l]=ind[l+1]; ind[l+1]=temp;}
1406
1407 i=l+1; //initialize pointers for partitioning
1408 j=ir;
1409 arr = ind[l+1];
1410 for (;;){
1411 do i++; while (a[ind[i]]<a[arr]);
1412 do j--; while (a[ind[j]]>a[arr]);
1413 if (j<i) break; //pointers crossed, partitioning complete
1414 {temp=ind[i]; ind[i]=ind[j]; ind[j]=temp;}
1415 }
1416 ind[l+1]=ind[j];
1417 ind[j]=arr;
1418 if (j>=rk) ir = j-1; //keep active the partition that
1419 if (j<=rk) l=i; //contains the k_th element
1420 }
1421 }
1422}
1423
1424#endif
#define d(i)
Definition: RSha256.hxx:102
#define c(i)
Definition: RSha256.hxx:101
bool Bool_t
Definition: RtypesCore.h:63
int Int_t
Definition: RtypesCore.h:45
const Bool_t kFALSE
Definition: RtypesCore.h:101
long Long_t
Definition: RtypesCore.h:54
unsigned int UInt_t
Definition: RtypesCore.h:46
float Float_t
Definition: RtypesCore.h:57
double Double_t
Definition: RtypesCore.h:59
long double LongDouble_t
Definition: RtypesCore.h:61
long long Long64_t
Definition: RtypesCore.h:80
const Bool_t kTRUE
Definition: RtypesCore.h:100
unsigned long ULong_t
Definition: RtypesCore.h:55
const char Option_t
Definition: RtypesCore.h:66
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
#define N
TGLVector3 Cross(const TGLVector3 &v1, const TGLVector3 &v2)
Definition: TGLUtil.h:323
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 char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t mask
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 b
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 np
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 r
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
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
float xmin
Definition: THbookFile.cxx:95
float * q
Definition: THbookFile.cxx:89
float xmax
Definition: THbookFile.cxx:95
RooCmdArg Index(RooCategory &icat)
double beta(double x, double y)
Calculates the beta function.
RVec< PromoteType< T > > cosh(const RVec< T > &v)
Definition: RVec.hxx:1784
RVec< PromoteType< T > > tan(const RVec< T > &v)
Definition: RVec.hxx:1777
RVec< PromoteType< T > > cos(const RVec< T > &v)
Definition: RVec.hxx:1776
RVec< PromoteType< T > > floor(const RVec< T > &v)
Definition: RVec.hxx:1790
RVec< PromoteTypes< T0, T1 > > pow(const T0 &x, const RVec< T1 > &v)
Definition: RVec.hxx:1770
RVec< PromoteType< T > > ceil(const RVec< T > &v)
Definition: RVec.hxx:1791
RVec< PromoteType< T > > asin(const RVec< T > &v)
Definition: RVec.hxx:1778
RVec< PromoteType< T > > log(const RVec< T > &v)
Definition: RVec.hxx:1765
RVec< PromoteTypes< T0, T1 > > atan2(const T0 &x, const RVec< T1 > &v)
Definition: RVec.hxx:1781
RVec< PromoteType< T > > sinh(const RVec< T > &v)
Definition: RVec.hxx:1783
RVec< PromoteType< T > > log10(const RVec< T > &v)
Definition: RVec.hxx:1766
RVec< PromoteType< T > > exp(const RVec< T > &v)
Definition: RVec.hxx:1761
RVec< PromoteType< T > > tanh(const RVec< T > &v)
Definition: RVec.hxx:1785
RVec< PromoteType< T > > acos(const RVec< T > &v)
Definition: RVec.hxx:1779
RVec< PromoteType< T > > atan(const RVec< T > &v)
Definition: RVec.hxx:1780
RVec< PromoteType< T > > sin(const RVec< T > &v)
Definition: RVec.hxx:1775
const Double_t sigma
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
const Int_t n
Definition: legend1.C:16
#define F(x, y, z)
Namespace for new Math classes and functions.
double gamma(double x)
double T(double x)
Definition: ChebyshevPol.h:34
VecExpr< UnaryOp< Sqrt< T >, VecExpr< A, T, D >, T >, T, D > sqrt(const VecExpr< A, T, D > &rhs)
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
static constexpr double s
TMath.
Definition: TMathBase.h:35
Double_t FDistI(Double_t F, Double_t N, Double_t M)
Calculates the cumulative distribution function of F-distribution, this function occurs in the statis...
Definition: TMath.cxx:2292
Double_t GeomMean(Long64_t n, const T *a)
Returns the geometric mean of an array a of size n.
Definition: TMath.h:1121
Double_t LogNormal(Double_t x, Double_t sigma, Double_t theta=0, Double_t m=1)
Computes the density of LogNormal distribution at point x.
Definition: TMath.cxx:2432
constexpr Double_t G()
Gravitational constant in: .
Definition: TMath.h:135
Double_t CosH(Double_t)
Returns the hyperbolic cosine of x.
Definition: TMath.h:610
T * Normal2Plane(const T v1[3], const T v2[3], const T v3[3], T normal[3])
Calculates a normal vector of a plane.
Definition: TMath.h:1210
Double_t DiLog(Double_t x)
Modified Struve functions of order 1.
Definition: TMath.cxx:116
Double_t BetaDist(Double_t x, Double_t p, Double_t q)
Computes the probability density function of the Beta distribution (the distribution function is comp...
Definition: TMath.cxx:2071
Double_t ACos(Double_t)
Returns the principal value of the arc cosine of x, expressed in radians.
Definition: TMath.h:630
Double_t BesselI(Int_t n, Double_t x)
Computes the Integer Order Modified Bessel function I_n(x) for n=0,1,2,... and any real x.
Definition: TMath.cxx:1590
Element KOrdStat(Size n, const Element *a, Size k, Size *work=0)
Returns k_th order statistic of the array a of size n (k_th smallest element out of n elements).
Definition: TMath.h:1357
Double_t Gaus(Double_t x, Double_t mean=0, Double_t sigma=1, Bool_t norm=kFALSE)
Calculates a gaussian function with mean and sigma.
Definition: TMath.cxx:471
Bool_t IsNaN(Double_t x)
Definition: TMath.h:890
constexpr Double_t GUncertainty()
Gravitational constant uncertainty.
Definition: TMath.h:150
constexpr Double_t C()
Velocity of light in .
Definition: TMath.h:114
Double_t Factorial(Int_t i)
Computes factorial(n).
Definition: TMath.cxx:252
Double_t KolmogorovTest(Int_t na, const Double_t *a, Int_t nb, const Double_t *b, Option_t *option)
Statistical test whether two one-dimensional sets of points are compatible with coming from the same ...
Definition: TMath.cxx:805
constexpr Double_t GhbarCUncertainty()
uncertainty.
Definition: TMath.h:166
Long64_t LocMin(Long64_t n, const T *a)
Returns index of array with the minimum element.
Definition: TMath.h:980
constexpr Double_t Ccgs()
Definition: TMath.h:121
constexpr Double_t SigmaUncertainty()
Stefan-Boltzmann constant uncertainty.
Definition: TMath.h:277
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition: TMath.h:691
Double_t BinomialI(Double_t p, Int_t n, Int_t k)
Suppose an event occurs with probability p per trial Then the probability P of its occurring k or mor...
Definition: TMath.cxx:2137
Double_t Vavilov(Double_t x, Double_t kappa, Double_t beta2)
Returns the value of the Vavilov density function.
Definition: TMath.cxx:2769
Double_t Binomial(Int_t n, Int_t k)
Calculates the binomial coefficient n over k.
Definition: TMath.cxx:2110
Float_t Normalize(Float_t v[3])
Normalize a vector v in place.
Definition: TMath.cxx:518
constexpr Double_t NaUncertainty()
Avogadro constant (Avogadro's Number) uncertainty.
Definition: TMath.h:291
Double_t Prob(Double_t chi2, Int_t ndf)
Computation of the probability for a certain Chi-squared (chi2) and number of degrees of freedom (ndf...
Definition: TMath.cxx:637
Bool_t IsInside(T xp, T yp, Int_t np, T *x, T *y)
Function which returns kTRUE if point xp,yp lies inside the polygon defined by the np points in array...
Definition: TMath.h:1231
Double_t ASin(Double_t)
Returns the principal value of the arc sine of x, expressed in radians.
Definition: TMath.h:622
Double_t Log2(Double_t x)
Returns the binary (base-2) logarithm of x.
Definition: TMath.cxx:107
Double_t BesselK1(Double_t x)
Modified Bessel function I_1(x)
Definition: TMath.cxx:1529
void BubbleHigh(Int_t Narr, Double_t *arr1, Int_t *arr2)
Bubble sort variant to obtain the order of an array's elements into an index in order to do more usef...
Definition: TMath.cxx:1314
Double_t Exp(Double_t x)
Returns the base-e exponential function of x, which is e raised to the power x.
Definition: TMath.h:707
Double_t BesselI1(Double_t x)
Modified Bessel function K_0(x)
Definition: TMath.cxx:1494
Double_t Erf(Double_t x)
Computation of the error function erf(x).
Definition: TMath.cxx:190
Bool_t Permute(Int_t n, Int_t *a)
Simple recursive algorithm to find the permutations of n natural numbers, not necessarily all distinc...
Definition: TMath.cxx:2552
Double_t QuietNaN()
Returns a quiet NaN as defined by IEEE 754.
Definition: TMath.h:900
Double_t Floor(Double_t x)
Rounds x downward, returning the largest integral value that is not greater than x.
Definition: TMath.h:678
Double_t PoissonI(Double_t x, Double_t par)
Computes the Discrete Poisson distribution function for (x,par).
Definition: TMath.cxx:615
Double_t CauchyDist(Double_t x, Double_t t=0, Double_t s=1)
Computes the density of Cauchy distribution at point x by default, standard Cauchy distribution is us...
Definition: TMath.cxx:2171
Double_t ATan(Double_t)
Returns the principal value of the arc tangent of x, expressed in radians.
Definition: TMath.h:638
Double_t StruveL1(Double_t x)
Modified Struve functions of order 0.
Definition: TMath.cxx:1970
constexpr Double_t Gn()
Standard acceleration of gravity in .
Definition: TMath.h:174
Double_t ASinH(Double_t)
Returns the area hyperbolic sine of x.
Definition: TMath.cxx:67
Double_t LaplaceDistI(Double_t x, Double_t alpha=0, Double_t beta=1)
Computes the distribution function of Laplace distribution at point x, with location parameter alpha ...
Definition: TMath.cxx:2375
ULong_t Hash(const void *txt, Int_t ntxt)
Calculates hash index from any char string.
Definition: TMath.cxx:1408
Double_t Normalize(Double_t v[3])
Normalize a vector v in place.
Definition: TMath.cxx:535
constexpr Double_t QeUncertainty()
Elementary charge uncertainty.
Definition: TMath.h:346
constexpr Double_t K()
Boltzmann's constant in : .
Definition: TMath.h:247
Double_t BreitWigner(Double_t x, Double_t mean=0, Double_t gamma=1)
Calculates a Breit Wigner function with mean and gamma.
Definition: TMath.cxx:442
constexpr Double_t Sqrt2()
Definition: TMath.h:86
constexpr Double_t KUncertainty()
Boltzmann's constant uncertainty.
Definition: TMath.h:261
constexpr Double_t Hbarcgs()
Definition: TMath.h:218
Double_t Landau(Double_t x, Double_t mpv=0, Double_t sigma=1, Bool_t norm=kFALSE)
The LANDAU function.
Definition: TMath.cxx:492
Double_t Voigt(Double_t x, Double_t sigma, Double_t lg, Int_t r=4)
Computation of Voigt function (normalised).
Definition: TMath.cxx:898
Double_t Student(Double_t T, Double_t ndf)
Computes density function for Student's t- distribution (the probability function (integral of densit...
Definition: TMath.cxx:2618
constexpr Double_t CUncertainty()
Speed of light uncertainty.
Definition: TMath.h:128
constexpr Double_t Qe()
Elementary charge in .
Definition: TMath.h:339
Double_t Ceil(Double_t x)
Rounds x upward, returning the smallest integral value that is not less than x.
Definition: TMath.h:666
constexpr Double_t PiOver2()
Definition: TMath.h:51
constexpr Double_t HCcgs()
Definition: TMath.h:240
T MinElement(Long64_t n, const T *a)
Returns minimum of array a of length n.
Definition: TMath.h:958
Double_t BetaDistI(Double_t x, Double_t p, Double_t q)
Computes the distribution function of the Beta distribution.
Definition: TMath.cxx:2089
T NormCross(const T v1[3], const T v2[3], T out[3])
Calculates the Normalized Cross Product of two vectors.
Definition: TMath.h:949
Int_t Finite(Double_t x)
Check if it is finite with a mask in order to be consistent in presence of fast math.
Definition: TMath.h:768
Double_t TanH(Double_t)
Returns the hyperbolic tangent of x.
Definition: TMath.h:616
Int_t FloorNint(Double_t x)
Returns the nearest integer of TMath::Floor(x).
Definition: TMath.h:684
Double_t ACosH(Double_t)
Returns the nonnegative area hyperbolic cosine of x.
Definition: TMath.cxx:81
Double_t BesselK0(Double_t x)
Modified Bessel function I_0(x)
Definition: TMath.cxx:1460
Double_t BesselY0(Double_t x)
Bessel function J1(x) for any real x.
Definition: TMath.cxx:1705
Double_t ATan2(Double_t y, Double_t x)
Returns the principal value of the arc tangent of y/x, expressed in radians.
Definition: TMath.h:644
constexpr Double_t RUncertainty()
Universal gas constant uncertainty.
Definition: TMath.h:309
Double_t BetaCf(Double_t x, Double_t a, Double_t b)
Continued fraction evaluation by modified Lentz's method used in calculation of incomplete Beta funct...
Definition: TMath.cxx:2020
Long64_t LocMax(Long64_t n, const T *a)
Returns index of array with the maximum element.
Definition: TMath.h:1010
Double_t ErfInverse(Double_t x)
Returns the inverse error function.
Definition: TMath.cxx:208
Double_t LaplaceDist(Double_t x, Double_t alpha=0, Double_t beta=1)
Computes the probability density function of Laplace distribution at point x, with location parameter...
Definition: TMath.cxx:2359
constexpr Double_t E()
Base of natural log: .
Definition: TMath.h:93
constexpr Double_t GnUncertainty()
Standard acceleration of gravity uncertainty.
Definition: TMath.h:181
constexpr Double_t Hcgs()
Definition: TMath.h:195
constexpr Double_t HUncertainty()
Planck's constant uncertainty.
Definition: TMath.h:202
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Definition: TMath.h:754
constexpr Double_t DegToRad()
Conversion from degree to radian: .
Definition: TMath.h:79
Double_t Mean(Long64_t n, const T *a, const Double_t *w=0)
Returns the weighted mean of an array a with length n.
Definition: TMath.h:1087
Double_t Erfc(Double_t x)
Computes the complementary error function erfc(x).
Definition: TMath.cxx:199
Double_t VavilovI(Double_t x, Double_t kappa, Double_t beta2)
Returns the value of the Vavilov distribution function.
Definition: TMath.cxx:2802
constexpr Double_t Sigma()
Stefan-Boltzmann constant in : .
Definition: TMath.h:270
Double_t Beta(Double_t p, Double_t q)
Calculates Beta-function Gamma(p)*Gamma(q)/Gamma(p+q).
Definition: TMath.cxx:2011
constexpr Double_t Kcgs()
Definition: TMath.h:254
Double_t Sq(Double_t x)
Returns x*x.
Definition: TMath.h:654
Double_t Poisson(Double_t x, Double_t par)
Computes the Poisson distribution function for (x,par).
Definition: TMath.cxx:587
constexpr Double_t H()
Planck's constant in : .
Definition: TMath.h:188
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition: TMath.h:660
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition: TMath.h:719
Int_t CeilNint(Double_t x)
Returns the nearest integer of TMath::Ceil(x).
Definition: TMath.h:672
Double_t Ldexp(Double_t x, Int_t exp)
Returns the result of multiplying x (the significant) by 2 raised to the power of exp (the exponent).
Definition: TMath.h:713
Double_t BesselJ0(Double_t x)
Modified Bessel function K_1(x)
Definition: TMath.cxx:1634
constexpr Double_t LogE()
Base-10 log of e (to convert ln to log)
Definition: TMath.h:107
Double_t Gamma(Double_t z)
Computation of gamma(z) for all z.
Definition: TMath.cxx:353
constexpr Double_t MWair()
Molecular weight of dry air 1976 US Standard Atmosphere in or
Definition: TMath.h:317
constexpr Double_t Gcgs()
Definition: TMath.h:143
Double_t StruveL0(Double_t x)
Struve functions of order 1.
Definition: TMath.cxx:1923
Double_t NormQuantile(Double_t p)
Computes quantiles for standard normal distribution N(0, 1) at probability p.
Definition: TMath.cxx:2451
constexpr Double_t Ln10()
Natural log of 10 (to convert log to ln)
Definition: TMath.h:100
Double_t Hypot(Double_t x, Double_t y)
Returns sqrt(x*x + y*y)
Definition: TMath.cxx:59
constexpr Double_t EulerGamma()
Euler-Mascheroni Constant.
Definition: TMath.h:332
constexpr Double_t PiOver4()
Definition: TMath.h:58
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition: TMath.h:592
void Quantiles(Int_t n, Int_t nprob, Double_t *x, Double_t *quantiles, Double_t *prob, Bool_t isSorted=kTRUE, Int_t *index=nullptr, Int_t type=7)
Computes sample quantiles, corresponding to the given probabilities.
Definition: TMath.cxx:1207
constexpr Double_t Pi()
Definition: TMath.h:37
Double_t StruveH0(Double_t x)
Bessel function Y1(x) for positive x.
Definition: TMath.cxx:1777
constexpr Double_t R()
Universal gas constant ( ) in
Definition: TMath.h:302
Double_t LnGamma(Double_t z)
Computation of ln[gamma(z)] for all z.
Definition: TMath.cxx:509
Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec)
Comparing floating points.
Definition: TMath.h:425
Bool_t AreEqualAbs(Double_t af, Double_t bf, Double_t epsilon)
Comparing floating points.
Definition: TMath.h:418
Double_t KolmogorovProb(Double_t z)
Calculates the Kolmogorov distribution function,.
Definition: TMath.cxx:679
constexpr Double_t InvPi()
Definition: TMath.h:65
Bool_t RootsCubic(const Double_t coef[4], Double_t &a, Double_t &b, Double_t &c)
Calculates roots of polynomial of 3rd order a*x^3 + b*x^2 + c*x + d, where.
Definition: TMath.cxx:1107
Double_t ChisquareQuantile(Double_t p, Double_t ndf)
Evaluate the quantiles of the chi-squared probability distribution function.
Definition: TMath.cxx:2189
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition: TMath.h:586
Double_t FDist(Double_t F, Double_t N, Double_t M)
Computes the density function of F-distribution (probability function, integral of density,...
Definition: TMath.cxx:2273
Double_t RMS(Long64_t n, const T *a, const Double_t *w=0)
Returns the Standard Deviation of an array a with length n.
Definition: TMath.h:1186
Double_t SignalingNaN()
Returns a signaling NaN as defined by IEEE 754](http://en.wikipedia.org/wiki/NaN#Signaling_NaN).
Definition: TMath.h:908
Double_t BreitWignerRelativistic(Double_t x, Double_t median=0, Double_t gamma=1)
Calculates a Relativistic Breit Wigner function with median and gamma.
Definition: TMath.cxx:452
void Sort(Index n, const Element *a, Index *index, Bool_t down=kTRUE)
Sort the n elements of the array a of generic templated type Element.
Definition: TMathBase.h:431
T * Cross(const T v1[3], const T v2[3], T out[3])
Calculates the Cross Product of two vectors: out = [v1 x v2].
Definition: TMath.h:1195
void BubbleLow(Int_t Narr, Double_t *arr1, Int_t *arr2)
Opposite ordering of the array arr2[] to that of BubbleHigh.
Definition: TMath.cxx:1353
Double_t BesselK(Int_t n, Double_t x)
Integer order modified Bessel function I_n(x)
Definition: TMath.cxx:1561
constexpr Double_t Na()
Avogadro constant (Avogadro's Number) in .
Definition: TMath.h:284
Double_t Median(Long64_t n, const T *a, const Double_t *w=0, Long64_t *work=0)
Same as RMS.
Definition: TMath.h:1270
T MaxElement(Long64_t n, const T *a)
Returns maximum of array a of length n.
Definition: TMath.h:966
Double_t BesselJ1(Double_t x)
Bessel function J0(x) for any real x.
Definition: TMath.cxx:1669
Double_t BetaIncomplete(Double_t x, Double_t a, Double_t b)
Calculates the incomplete Beta-function.
Definition: TMath.cxx:2102
constexpr Double_t Rgair()
Dry Air Gas Constant (R / MWair) in
Definition: TMath.h:325
constexpr Double_t Hbar()
in :
Definition: TMath.h:211
Double_t StruveH1(Double_t x)
Struve functions of order 0.
Definition: TMath.cxx:1846
Double_t Freq(Double_t x)
Computation of the normal frequency function freq(x).
Definition: TMath.cxx:270
Double_t Tan(Double_t)
Returns the tangent of an angle of x radians.
Definition: TMath.h:598
Double_t LandauI(Double_t x)
Returns the value of the Landau distribution function at point x.
Definition: TMath.cxx:2831
Bool_t IsNaN(Float_t x)
Definition: TMath.h:891
Double_t ATanH(Double_t)
Returns the area hyperbolic tangent of x.
Definition: TMath.cxx:95
constexpr Double_t RadToDeg()
Conversion from radian to degree: .
Definition: TMath.h:72
Double_t BesselI0(Double_t x)
Integer order modified Bessel function K_n(x)
Definition: TMath.cxx:1426
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition: TMath.h:760
Double_t StudentI(Double_t T, Double_t ndf)
Calculates the cumulative distribution function of Student's t-distribution second parameter stands f...
Definition: TMath.cxx:2640
Double_t StudentQuantile(Double_t p, Double_t ndf, Bool_t lower_tail=kTRUE)
Computes quantiles of the Student's t-distribution 1st argument is the probability,...
Definition: TMath.cxx:2668
Double_t BesselY1(Double_t x)
Bessel function Y0(x) for positive x.
Definition: TMath.cxx:1739
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition: TMathBase.h:123
Double_t StdDev(Long64_t n, const T *a, const Double_t *w=0)
Definition: TMath.h:525
Double_t GammaDist(Double_t x, Double_t gamma, Double_t mu=0, Double_t beta=1)
Computes the density function of Gamma distribution at point x.
Definition: TMath.cxx:2342
constexpr Double_t GhbarC()
in
Definition: TMath.h:158
constexpr Double_t HC()
in
Definition: TMath.h:233
constexpr Double_t TwoPi()
Definition: TMath.h:44
constexpr Double_t HbarUncertainty()
uncertainty.
Definition: TMath.h:225
Double_t Infinity()
Returns an infinity as defined by the IEEE standard.
Definition: TMath.h:915
Double_t ErfcInverse(Double_t x)
Returns the inverse of the complementary error function.
Definition: TMath.cxx:242
Double_t SinH(Double_t)
Returns the hyperbolic sine of `x.
Definition: TMath.h:604
Definition: first.py:1
const char * Size
Definition: TXMLSetup.cxx:56
static T Min()
Returns maximum representation for type T.
Definition: TMath.h:923
static T Epsilon()
Returns minimum double representation.
Definition: TMath.h:939
static T Max()
Returns minimum double representation.
Definition: TMath.h:931
TMarker m
Definition: textangle.C:8
TLine l
Definition: textangle.C:4
TArc a
Definition: textangle.C:12
static uint64_t sum(uint64_t i)
Definition: Factory.cxx:2345
double epsilon
Definition: triangle.c:618