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 // Sign
52 inline Short_t Sign(Short_t a, Short_t b);
53 inline Int_t Sign(Int_t a, Int_t b);
54 inline Long_t Sign(Long_t a, Long_t b);
55 inline Long64_t Sign(Long64_t a, Long64_t b);
56 inline Float_t Sign(Float_t a, Float_t b);
57 inline Double_t Sign(Double_t a, Double_t b);
58
59 // Min, Max of two scalars
60 inline Short_t Min(Short_t a, Short_t b);
61 inline UShort_t Min(UShort_t a, UShort_t b);
62 inline Int_t Min(Int_t a, Int_t b);
63 inline UInt_t Min(UInt_t a, UInt_t b);
64 inline Long_t Min(Long_t a, Long_t b);
65 inline ULong_t Min(ULong_t a, ULong_t b);
66 inline Long64_t Min(Long64_t a, Long64_t b);
67 inline ULong64_t Min(ULong64_t a, ULong64_t b);
68 inline Float_t Min(Float_t a, Float_t b);
69 inline Double_t Min(Double_t a, Double_t b);
70
71 inline Short_t Max(Short_t a, Short_t b);
72 inline UShort_t Max(UShort_t a, UShort_t b);
73 inline Int_t Max(Int_t a, Int_t b);
74 inline UInt_t Max(UInt_t a, UInt_t b);
75 inline Long_t Max(Long_t a, Long_t b);
76 inline ULong_t Max(ULong_t a, ULong_t b);
77 inline Long64_t Max(Long64_t a, Long64_t b);
78 inline ULong64_t Max(ULong64_t a, ULong64_t b);
79 inline Float_t Max(Float_t a, Float_t b);
80 inline Double_t Max(Double_t a, Double_t b);
81
82 // Range
83 inline Short_t Range(Short_t lb, Short_t ub, Short_t x);
84 inline Int_t Range(Int_t lb, Int_t ub, Int_t x);
85 inline Long_t Range(Long_t lb, Long_t ub, Long_t x);
86 inline ULong_t Range(ULong_t lb, ULong_t ub, ULong_t x);
87 inline Double_t Range(Double_t lb, Double_t ub, Double_t x);
88
89 //NextPrime is used by the Core classes.
90 Long_t NextPrime(Long_t x); // Least prime number greater than x
91 }
92
93
94 //---- Even/odd ----------------------------------------------------------------
95
96 inline Bool_t TMath::Even(Long_t a)
97 { return ! (a & 1); }
98
99 inline Bool_t TMath::Odd(Long_t a)
100 { return (a & 1); }
101
102 //---- Abs ---------------------------------------------------------------------
103
104 inline Short_t TMath::Abs(Short_t d)
105 { return (d >= 0) ? d : Short_t(-d); }
106
107 inline Int_t TMath::Abs(Int_t d)
108 { return std::abs(d); }
109
110 inline Long_t TMath::Abs(Long_t d)
111 { return std::labs(d); }
112
113 inline Long64_t TMath::Abs(Long64_t d)
114 #if __cplusplus >= 201103
115 { return std::llabs(d); }
116 #else
117 { return (d >= 0) ? d : -d; }
118 #endif
119
120 inline Float_t TMath::Abs(Float_t d)
121 { return std::abs(d); }
122
123 inline Double_t TMath::Abs(Double_t d)
124 { return std::abs(d); }
125
126 inline LongDouble_t TMath::Abs(LongDouble_t d)
127 { return std::abs(d); }
128
129 //---- Sign --------------------------------------------------------------------
130
131 inline Short_t TMath::Sign(Short_t a, Short_t b)
132 { return (b >= 0) ? Abs(a) : Short_t(-Abs(a)); }
133
134 inline Int_t TMath::Sign(Int_t a, Int_t b)
135 { return (b >= 0) ? Abs(a) : -Abs(a); }
136
137 inline Long_t TMath::Sign(Long_t a, Long_t b)
138 { return (b >= 0) ? Abs(a) : -Abs(a); }
139
140 inline Long64_t TMath::Sign(Long64_t a, Long64_t b)
141 { return (b >= 0) ? Abs(a) : -Abs(a); }
142
143 inline Float_t TMath::Sign(Float_t a, Float_t b)
144 #if __cplusplus >= 201103
145 { return std::copysign(a,b); }
146 #else
147 { return (b >= 0) ? Abs(a) : -Abs(a); }
148 #endif
149
150 inline Double_t TMath::Sign(Double_t a, Double_t b)
151 #if __cplusplus >= 201103
152 { return std::copysign(a,b); }
153 #else
154 { return (b >= 0) ? Abs(a) : -Abs(a); }
155 #endif
156
157 //---- Min ---------------------------------------------------------------------
158
159 inline Short_t TMath::Min(Short_t a, Short_t b)
160 { return a <= b ? a : b; }
161
162 inline UShort_t TMath::Min(UShort_t a, UShort_t b)
163 { return a <= b ? a : b; }
164
165 inline Int_t TMath::Min(Int_t a, Int_t b)
166 { return a <= b ? a : b; }
167
168 inline UInt_t TMath::Min(UInt_t a, UInt_t b)
169 { return a <= b ? a : b; }
170
171 inline Long_t TMath::Min(Long_t a, Long_t b)
172 { return a <= b ? a : b; }
173
174 inline ULong_t TMath::Min(ULong_t a, ULong_t b)
175 { return a <= b ? a : b; }
176
177 inline Long64_t TMath::Min(Long64_t a, Long64_t b)
178 { return a <= b ? a : b; }
179
180 inline ULong64_t TMath::Min(ULong64_t a, ULong64_t b)
181 { return a <= b ? a : b; }
182
183 inline Float_t TMath::Min(Float_t a, Float_t b)
184 { return a <= b ? a : b; }
185
186 inline Double_t TMath::Min(Double_t a, Double_t b)
187 { return a <= b ? a : b; }
188
189 //---- Max ---------------------------------------------------------------------
190
191 inline Short_t TMath::Max(Short_t a, Short_t b)
192 { return a >= b ? a : b; }
193
194 inline UShort_t TMath::Max(UShort_t a, UShort_t b)
195 { return a >= b ? a : b; }
196
197 inline Int_t TMath::Max(Int_t a, Int_t b)
198 { return a >= b ? a : b; }
199
200 inline UInt_t TMath::Max(UInt_t a, UInt_t b)
201 { return a >= b ? a : b; }
202
203 inline Long_t TMath::Max(Long_t a, Long_t b)
204 { return a >= b ? a : b; }
205
206 inline ULong_t TMath::Max(ULong_t a, ULong_t b)
207 { return a >= b ? a : b; }
208
209 inline Long64_t TMath::Max(Long64_t a, Long64_t b)
210 { return a >= b ? a : b; }
211
212 inline ULong64_t TMath::Max(ULong64_t a, ULong64_t b)
213 { return a >= b ? a : b; }
214
215 inline Float_t TMath::Max(Float_t a, Float_t b)
216 { return a >= b ? a : b; }
217
218 inline Double_t TMath::Max(Double_t a, Double_t b)
219 { return a >= b ? a : b; }
220
221 //---- Range -------------------------------------------------------------------
222
223 inline Short_t TMath::Range(Short_t lb, Short_t ub, Short_t x)
224 { return x < lb ? lb : (x > ub ? ub : x); }
225
226 inline Int_t TMath::Range(Int_t lb, Int_t ub, Int_t x)
227 { return x < lb ? lb : (x > ub ? ub : x); }
228
229 inline Long_t TMath::Range(Long_t lb, Long_t ub, Long_t x)
230 { return x < lb ? lb : (x > ub ? ub : x); }
231
232 inline ULong_t TMath::Range(ULong_t lb, ULong_t ub, ULong_t x)
233 { return x < lb ? lb : (x > ub ? ub : x); }
234
235 inline Double_t TMath::Range(Double_t lb, Double_t ub, Double_t x)
236 { return x < lb ? lb : (x > ub ? ub : x); }
237
238
239 #endif
240