source: ntrip/branches/BNC_2.12/newmat/precisio.h

Last change on this file was 2013, checked in by mervart, 13 years ago

* empty log message *

File size: 6.5 KB
Line 
1/// \ingroup newmat
2///@{
3
4/// \file precisio.h
5/// Floating point precision constants.
6
7#ifndef PRECISION_LIB
8#define PRECISION_LIB 0
9
10#define WANT_MATH
11#include "include.h" // in case being used as stand alone
12
13#ifdef _STANDARD_ // standard library available
14#include <limits>
15#endif
16
17#ifdef use_namespace
18namespace NEWMAT {
19#endif
20
21#ifdef _STANDARD_ // standard library available
22
23#ifdef OPT_COMPATIBLE
24#include <cfloat> // for FLT_MAX
25#endif
26
27/// Floating point precision.
28class FloatingPointPrecision
29{
30public:
31 static int Dig() // number of decimal digits or precision
32 { return std::numeric_limits<Real>::digits10 ; }
33
34 static Real Epsilon() // smallest number such that 1+Eps!=Eps
35 { return std::numeric_limits<Real>::epsilon(); }
36
37 static int Mantissa() // bits in mantisa
38 { return std::numeric_limits<Real>::digits; }
39
40 static Real Maximum() // maximum value
41 { return std::numeric_limits<Real>::max(); }
42
43 static int MaximumDecimalExponent() // maximum decimal exponent
44 { return std::numeric_limits<Real>::max_exponent10; }
45
46 static int MaximumExponent() // maximum binary exponent
47 { return std::numeric_limits<Real>::max_exponent; }
48
49 static Real LnMaximum() // natural log of maximum
50 { return (Real)log(Maximum()); }
51
52 static Real Minimum() // minimum positive value
53 { return std::numeric_limits<Real>::min(); }
54
55 static int MinimumDecimalExponent() // minimum decimal exponent
56 { return std::numeric_limits<Real>::min_exponent10; }
57
58 static int MinimumExponent() // minimum binary exponent
59 { return std::numeric_limits<Real>::min_exponent; }
60
61 static Real LnMinimum() // natural log of minimum
62 { return (Real)log(Minimum()); }
63
64 static int Radix() // exponent radix
65 { return std::numeric_limits<Real>::radix; }
66
67 static int Rounds() // addition rounding (1 = does round)
68 {
69 return std::numeric_limits<Real>::round_style ==
70 std::round_to_nearest ? 1 : 0;
71 }
72
73};
74
75
76#else // _STANDARD_ not defined
77
78#ifndef SystemV // if there is float.h
79
80#ifdef USING_FLOAT
81
82/// Floating point precision (type float).
83class FloatingPointPrecision
84{
85public:
86 static int Dig()
87 { return FLT_DIG; } // number of decimal digits or precision
88
89 static Real Epsilon()
90 { return FLT_EPSILON; } // smallest number such that 1+Eps!=Eps
91
92 static int Mantissa()
93 { return FLT_MANT_DIG; } // bits in mantisa
94
95 static Real Maximum()
96 { return FLT_MAX; } // maximum value
97
98 static int MaximumDecimalExponent()
99 { return FLT_MAX_10_EXP; } // maximum decimal exponent
100
101 static int MaximumExponent()
102 { return FLT_MAX_EXP; } // maximum binary exponent
103
104 static Real LnMaximum()
105 { return (Real)log(Maximum()); } // natural log of maximum
106
107 static Real Minimum()
108 { return FLT_MIN; } // minimum positive value
109
110 static int MinimumDecimalExponent()
111 { return FLT_MIN_10_EXP; } // minimum decimal exponent
112
113 static int MinimumExponent()
114 { return FLT_MIN_EXP; } // minimum binary exponent
115
116 static Real LnMinimum()
117 { return (Real)log(Minimum()); } // natural log of minimum
118
119 static int Radix()
120 { return FLT_RADIX; } // exponent radix
121
122 static int Rounds()
123 { return FLT_ROUNDS; } // addition rounding (1 = does round)
124
125};
126
127#endif // USING_FLOAT
128
129
130#ifdef USING_DOUBLE
131
132/// Floating point precision (type double).
133class FloatingPointPrecision
134{
135public:
136
137 static int Dig()
138 { return DBL_DIG; } // number of decimal digits or precision
139
140 static Real Epsilon()
141 { return DBL_EPSILON; } // smallest number such that 1+Eps!=Eps
142
143 static int Mantissa()
144 { return DBL_MANT_DIG; } // bits in mantisa
145
146 static Real Maximum()
147 { return DBL_MAX; } // maximum value
148
149 static int MaximumDecimalExponent()
150 { return DBL_MAX_10_EXP; } // maximum decimal exponent
151
152 static int MaximumExponent()
153 { return DBL_MAX_EXP; } // maximum binary exponent
154
155 static Real LnMaximum()
156 { return (Real)log(Maximum()); } // natural log of maximum
157
158 static Real Minimum()
159 {
160//#ifdef __BCPLUSPLUS__
161// return 2.225074e-308; // minimum positive value
162//#else
163 return DBL_MIN;
164//#endif
165 }
166
167 static int MinimumDecimalExponent()
168 { return DBL_MIN_10_EXP; } // minimum decimal exponent
169
170 static int MinimumExponent()
171 { return DBL_MIN_EXP; } // minimum binary exponent
172
173 static Real LnMinimum()
174 { return (Real)log(Minimum()); } // natural log of minimum
175
176
177 static int Radix()
178 { return FLT_RADIX; } // exponent radix
179
180 static int Rounds()
181 { return FLT_ROUNDS; } // addition rounding (1 = does round)
182
183};
184
185#endif // USING_DOUBLE
186
187#else // if there is no float.h
188
189#ifdef OPT_COMPATIBLE
190#define FLT_MAX MAXFLOAT
191#endif
192
193
194#ifdef USING_FLOAT
195
196/// Floating point precision (type float).
197class FloatingPointPrecision
198{
199public:
200
201 static Real Epsilon()
202 { return pow(2.0,(int)(1-FSIGNIF)); }
203 // smallest number such that 1+Eps!=Eps
204
205 static Real Maximum()
206 { return MAXFLOAT; } // maximum value
207
208 static Real LnMaximum()
209 { return (Real)log(Maximum()); } // natural log of maximum
210
211 static Real Minimum()
212 { return MINFLOAT; } // minimum positive value
213
214 static Real LnMinimum()
215 { return (Real)log(Minimum()); } // natural log of minimum
216
217};
218
219#endif // USING_FLOAT
220
221
222#ifdef USING_DOUBLE
223
224/// Floating point precision (type double).
225class FloatingPointPrecision
226{
227public:
228
229 static Real Epsilon()
230 { return pow(2.0,(int)(1-DSIGNIF)); }
231 // smallest number such that 1+Eps!=Eps
232
233 static Real Maximum()
234 { return MAXDOUBLE; } // maximum value
235
236 static Real LnMaximum()
237 { return LN_MAXDOUBLE; } // natural log of maximum
238
239 static Real Minimum()
240 { return MINDOUBLE; }
241
242 static Real LnMinimum()
243 { return LN_MINDOUBLE; } // natural log of minimum
244};
245
246#endif // USING_DOUBLE
247
248#endif // SystemV
249
250#endif // _STANDARD_
251
252
253
254
255#ifdef use_namespace
256}
257#endif // use_namespace
258
259
260
261#endif // PRECISION_LIB
262
263
264///@}
Note: See TracBrowser for help on using the repository browser.