ROOT  6.06/09
Reference Guide
TMathBase.h
Go to the documentation of this file.
1 // @(#)root/base:
2 // Authors: Rene Brun, 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_TMathBase
13 #define ROOT_TMathBase
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TMath Base functions //
19 // //
20 // Define the functions Min, Max, Abs, Sign, Range for all types. //
21 // NB: These functions are unfortunately not available in a portable //
22 // way in std::. //
23 // //
24 // More functions are defined in TMath.h. TMathBase.h is designed to be //
25 // a stable file and used in place of TMath.h in the ROOT miniCore. //
26 // //
27 //////////////////////////////////////////////////////////////////////////
28 
29 #ifndef ROOT_Rtypes
30 #include "Rtypes.h"
31 #endif
32 
33 #include <cstdlib>
34 #include <cmath>
35 
36 namespace TMath {
37 
38  // Abs
39  inline Short_t Abs(Short_t d);
40  inline Int_t Abs(Int_t d);
41  inline Long_t Abs(Long_t d);
42  inline Long64_t Abs(Long64_t d);
43  inline Float_t Abs(Float_t d);
44  inline Double_t Abs(Double_t d);
45  inline LongDouble_t Abs(LongDouble_t d);
46 
47  // Even/Odd
48  inline Bool_t Even(Long_t a);
49  inline Bool_t Odd(Long_t a);
50 
51  // SignBit
52  template<typename Integer>
53  inline Bool_t SignBit(Integer a);
54  inline Bool_t SignBit(Float_t a);
55  inline Bool_t SignBit(Double_t a);
56  inline Bool_t SignBit(LongDouble_t a);
57 
58  // Sign
59  template<typename T1, typename T2>
60  inline T1 Sign( T1 a, T2 b);
61  inline Float_t Sign(Float_t a, Float_t b);
62  inline Double_t Sign(Double_t a, Double_t b);
63  inline LongDouble_t Sign(LongDouble_t a, LongDouble_t b);
64 
65  // Min, Max of two scalars
66  inline Short_t Min(Short_t a, Short_t b);
67  inline UShort_t Min(UShort_t a, UShort_t b);
68  inline Int_t Min(Int_t a, Int_t b);
69  inline UInt_t Min(UInt_t a, UInt_t b);
70  inline Long_t Min(Long_t a, Long_t b);
71  inline ULong_t Min(ULong_t a, ULong_t b);
72  inline Long64_t Min(Long64_t a, Long64_t b);
73  inline ULong64_t Min(ULong64_t a, ULong64_t b);
74  inline Float_t Min(Float_t a, Float_t b);
75  inline Double_t Min(Double_t a, Double_t b);
76 
77  inline Short_t Max(Short_t a, Short_t b);
78  inline UShort_t Max(UShort_t a, UShort_t b);
79  inline Int_t Max(Int_t a, Int_t b);
80  inline UInt_t Max(UInt_t a, UInt_t b);
81  inline Long_t Max(Long_t a, Long_t b);
82  inline ULong_t Max(ULong_t a, ULong_t b);
83  inline Long64_t Max(Long64_t a, Long64_t b);
84  inline ULong64_t Max(ULong64_t a, ULong64_t b);
85  inline Float_t Max(Float_t a, Float_t b);
86  inline Double_t Max(Double_t a, Double_t b);
87 
88  // Range
89  inline Short_t Range(Short_t lb, Short_t ub, Short_t x);
90  inline Int_t Range(Int_t lb, Int_t ub, Int_t x);
91  inline Long_t Range(Long_t lb, Long_t ub, Long_t x);
92  inline ULong_t Range(ULong_t lb, ULong_t ub, ULong_t x);
93  inline Double_t Range(Double_t lb, Double_t ub, Double_t x);
94 
95  //NextPrime is used by the Core classes.
96  Long_t NextPrime(Long_t x); // Least prime number greater than x
97 }
98 
99 
100 //---- Even/odd ----------------------------------------------------------------
101 
102 inline Bool_t TMath::Even(Long_t a)
103  { return ! (a & 1); }
104 
105 inline Bool_t TMath::Odd(Long_t a)
106  { return (a & 1); }
107 
108 //---- Abs ---------------------------------------------------------------------
109 
110 inline Short_t TMath::Abs(Short_t d)
111 { return (d >= 0) ? d : Short_t(-d); }
112 
113 inline Int_t TMath::Abs(Int_t d)
114 { return std::abs(d); }
115 
116 inline Long_t TMath::Abs(Long_t d)
117 { return std::labs(d); }
118 
119 inline Long64_t TMath::Abs(Long64_t d)
120 #if __cplusplus >= 201103
121 { return std::llabs(d); }
122 #else
123 { return (d >= 0) ? d : -d; }
124 #endif
125 
126 inline Float_t TMath::Abs(Float_t d)
127 { return std::abs(d); }
128 
129 inline Double_t TMath::Abs(Double_t d)
130 { return std::abs(d); }
131 
132 inline LongDouble_t TMath::Abs(LongDouble_t d)
133 { return std::abs(d); }
134 
135 
136 //---- Sign Bit--------------------------------------------------------------------
137 
138 template<typename Integer>
139 inline Bool_t TMath::SignBit( Integer a)
140  { return (a < 0); }
141 
142 inline Bool_t TMath::SignBit(Float_t a)
143  { return std::signbit(a); }
144 
145 inline Bool_t TMath::SignBit(Double_t a)
146  { return std::signbit(a); }
147 
148 inline Bool_t TMath::SignBit(LongDouble_t a)
149  { return std::signbit(a); }
150 
151 
152 //---- Sign --------------------------------------------------------------------
153 
154 template<typename T1, typename T2>
155 inline T1 TMath::Sign( T1 a, T2 b)
156  { return (SignBit(b)) ? - Abs(a) : Abs(a); }
157 
158 inline Float_t TMath::Sign(Float_t a, Float_t b)
159  { return std::copysign(a,b); }
160 
161 inline Double_t TMath::Sign(Double_t a, Double_t b)
162  { return std::copysign(a,b); }
163 
164 inline LongDouble_t TMath::Sign(LongDouble_t a, LongDouble_t b)
165  { return std::copysign(a,b); }
166 
167 
168 //---- Min ---------------------------------------------------------------------
169 
170 inline Short_t TMath::Min(Short_t a, Short_t b)
171  { return a <= b ? a : b; }
172 
173 inline UShort_t TMath::Min(UShort_t a, UShort_t b)
174  { return a <= b ? a : b; }
175 
176 inline Int_t TMath::Min(Int_t a, Int_t b)
177  { return a <= b ? a : b; }
178 
179 inline UInt_t TMath::Min(UInt_t a, UInt_t b)
180  { return a <= b ? a : b; }
181 
182 inline Long_t TMath::Min(Long_t a, Long_t b)
183  { return a <= b ? a : b; }
184 
185 inline ULong_t TMath::Min(ULong_t a, ULong_t b)
186  { return a <= b ? a : b; }
187 
188 inline Long64_t TMath::Min(Long64_t a, Long64_t b)
189  { return a <= b ? a : b; }
190 
191 inline ULong64_t TMath::Min(ULong64_t a, ULong64_t b)
192  { return a <= b ? a : b; }
193 
194 inline Float_t TMath::Min(Float_t a, Float_t b)
195  { return a <= b ? a : b; }
196 
197 inline Double_t TMath::Min(Double_t a, Double_t b)
198  { return a <= b ? a : b; }
199 
200 //---- Max ---------------------------------------------------------------------
201 
202 inline Short_t TMath::Max(Short_t a, Short_t b)
203  { return a >= b ? a : b; }
204 
205 inline UShort_t TMath::Max(UShort_t a, UShort_t b)
206  { return a >= b ? a : b; }
207 
208 inline Int_t TMath::Max(Int_t a, Int_t b)
209  { return a >= b ? a : b; }
210 
211 inline UInt_t TMath::Max(UInt_t a, UInt_t b)
212  { return a >= b ? a : b; }
213 
214 inline Long_t TMath::Max(Long_t a, Long_t b)
215  { return a >= b ? a : b; }
216 
217 inline ULong_t TMath::Max(ULong_t a, ULong_t b)
218  { return a >= b ? a : b; }
219 
220 inline Long64_t TMath::Max(Long64_t a, Long64_t b)
221  { return a >= b ? a : b; }
222 
223 inline ULong64_t TMath::Max(ULong64_t a, ULong64_t b)
224  { return a >= b ? a : b; }
225 
226 inline Float_t TMath::Max(Float_t a, Float_t b)
227  { return a >= b ? a : b; }
228 
229 inline Double_t TMath::Max(Double_t a, Double_t b)
230  { return a >= b ? a : b; }
231 
232 //---- Range -------------------------------------------------------------------
233 
234 inline Short_t TMath::Range(Short_t lb, Short_t ub, Short_t x)
235  { return x < lb ? lb : (x > ub ? ub : x); }
236 
237 inline Int_t TMath::Range(Int_t lb, Int_t ub, Int_t x)
238  { return x < lb ? lb : (x > ub ? ub : x); }
239 
240 inline Long_t TMath::Range(Long_t lb, Long_t ub, Long_t x)
241  { return x < lb ? lb : (x > ub ? ub : x); }
242 
243 inline ULong_t TMath::Range(ULong_t lb, ULong_t ub, ULong_t x)
244  { return x < lb ? lb : (x > ub ? ub : x); }
245 
246 inline Double_t TMath::Range(Double_t lb, Double_t ub, Double_t x)
247  { return x < lb ? lb : (x > ub ? ub : x); }
248 
249 
250 #endif
Long64_t
long long Long64_t
Definition: RtypesCore.h:69
TMath::Sign
T1 Sign(T1 a, T2 b)
Definition: TMathBase.h:155
Float_t
float Float_t
Definition: RtypesCore.h:53
UShort_t
unsigned short UShort_t
Definition: RtypesCore.h:36
TMath::Range
Short_t Range(Short_t lb, Short_t ub, Short_t x)
Definition: TMathBase.h:234
TMath::Min
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:170
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
a
TArc * a
Definition: textangle.C:12
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:110
TMath::Odd
Bool_t Odd(Long_t a)
Definition: TMathBase.h:105
x
Double_t x[n]
Definition: legend1.C:17
ROOT::Vc::AVX::abs
static Vc_ALWAYS_INLINE Vector< T > abs(const Vector< T > &x)
Definition: vector.h:450
TMath::Even
Bool_t Even(Long_t a)
Definition: TMathBase.h:102
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42
Short_t
short Short_t
Definition: RtypesCore.h:35
LongDouble_t
long double LongDouble_t
Definition: RtypesCore.h:57
Long_t
long Long_t
Definition: RtypesCore.h:50
TMath::NextPrime
Long_t NextPrime(Long_t x)
TMath Base functions.
Definition: TMathBase.cxx:29
Double_t
double Double_t
Definition: RtypesCore.h:55
ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:70
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51
T2
#define T2
Definition: md5.inl:146
T1
#define T1
Definition: md5.inl:145
TMath::SignBit
Bool_t SignBit(Integer a)
Definition: TMathBase.h:139
TMath::SignBit
Bool_t SignBit(LongDouble_t a)
Definition: TMathBase.h:148
TMath::Max
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:202
TMath::Abs
LongDouble_t Abs(LongDouble_t d)
Definition: TMathBase.h:132