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