VirtualBox

source: vbox/trunk/include/iprt/nocrt/limits

Last change on this file was 106061, checked in by vboxsync, 2 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.3 KB
Line 
1/** @file
2 * IPRT / No-CRT - C++ limits header.
3 */
4
5/*
6 * Copyright (C) 2022-2024 Oracle and/or its affiliates.
7 *
8 * This file is part of VirtualBox base platform packages, as
9 * available from https://www.virtualbox.org.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation, in version 3 of the
14 * License.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, see <https://www.gnu.org/licenses>.
23 *
24 * The contents of this file may alternatively be used under the terms
25 * of the Common Development and Distribution License Version 1.0
26 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
27 * in the VirtualBox distribution, in which case the provisions of the
28 * CDDL are applicable instead of those of the GPL.
29 *
30 * You may elect to license modified versions of this file under the
31 * terms and conditions of either the GPL or the CDDL or both.
32 *
33 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
34 */
35
36#ifndef VBOX_INCLUDED_SRC_nocrt_limits
37#define VBOX_INCLUDED_SRC_nocrt_limits
38#ifndef RT_WITHOUT_PRAGMA_ONCE
39# pragma once
40#endif
41
42#include <iprt/nocrt/limits.h>
43#include <iprt/nocrt/float.h>
44
45namespace std
46{
47 enum float_denorm_style
48 {
49 denorm_indeterminate = -1,
50 denorm_absent,
51 denorm_present,
52 };
53
54 enum float_round_style
55 {
56 round_indeterminate = -1,
57 round_toward_zero,
58 round_to_nearest,
59 round_toward_infinity,
60 round_toward_neg_infinity,
61 };
62
63 struct rtNoCrtLimitNumericBase
64 {
65 static const bool is_specialized = false;
66 static const bool is_integer = false;
67 static const bool is_signed = false;
68 static const bool is_exact = false;
69 static const bool is_bounded = false;
70
71 static const bool has_infinity = false;
72 static const bool has_quiet_NaN = false;
73 static const bool has_signaling_NaN = false;
74 static const bool has_denorm_loss = false;
75 static const bool is_iec559 = false;
76 static const bool is_modulo = false;
77 static const bool traps = false;
78 static const bool tinyness_before = false;
79
80 static const int digits = 0;
81 static const int digits10 = 0;
82 static const int max_digits10 = 0;
83 static const int radix = 0;
84 static const int min_exponent = 0;
85 static const int min_exponent10 = 0;
86 static const int max_exponent = 0;
87 static const int max_exponent10 = 0;
88
89 static const float_denorm_style has_denorm = denorm_absent;
90 static const float_round_style round_style = round_toward_zero;
91 };
92
93 struct rtNoCrtLimitNumericIntBase : public rtNoCrtLimitNumericBase
94 {
95 static const bool is_specialized = true;
96 static const bool is_integer = true;
97 static const bool is_exact = true;
98 static const bool is_bounded = true;
99 static const int radix = 2;
100 };
101
102 struct rtNoCrtLimitNumericFloatBase : public rtNoCrtLimitNumericBase
103 {
104 static const bool is_specialized = true;
105 static const bool is_signed = true;
106 static const bool is_bounded = true;
107 static const bool has_infinity = false;
108 static const bool has_quiet_NaN = false;
109 static const bool has_signaling_NaN = false;
110 static const bool is_iec559 = false;
111 static const int radix = FLT_RADIX;
112 static const float_denorm_style has_denorm = denorm_present;
113 static const float_round_style round_style = round_to_nearest;
114 };
115
116 /*
117 * Generic template.
118 */
119 template<typename a_Type>
120 struct numeric_limits : public rtNoCrtLimitNumericBase
121 {
122 /** @todo need a RT_CONSTEXPR_FN etc */
123 static constexpr a_Type(min)() RT_NOEXCEPT { return a_Type(); }
124 static constexpr a_Type(max)() RT_NOEXCEPT { return a_Type(); }
125 static constexpr a_Type lowest() RT_NOEXCEPT { return a_Type(); }
126 static constexpr a_Type epsilon() RT_NOEXCEPT { return a_Type(); }
127 static constexpr a_Type round_error() RT_NOEXCEPT { return a_Type(); }
128 static constexpr a_Type infinity() RT_NOEXCEPT { return a_Type(); }
129 static constexpr a_Type quiet_NaN() RT_NOEXCEPT { return a_Type(); }
130 static constexpr a_Type signaling_NaN() RT_NOEXCEPT { return a_Type(); }
131 static constexpr a_Type denorm_min() RT_NOEXCEPT { return a_Type(); }
132 };
133
134 /* const and volatile trickery: */
135 template<typename a_Type> struct numeric_limits<const a_Type> : public numeric_limits<a_Type> {};
136 template<typename a_Type> struct numeric_limits<volatile a_Type> : public numeric_limits<a_Type> {};
137 template<typename a_Type> struct numeric_limits<const volatile a_Type> : public numeric_limits<a_Type> {};
138
139 /*
140 * Integer specializations.
141 */
142 template<>
143 struct numeric_limits<bool> : public rtNoCrtLimitNumericIntBase
144 {
145 static constexpr bool(min)() RT_NOEXCEPT { return false; }
146 static constexpr bool(max)() RT_NOEXCEPT { return true; }
147 static constexpr bool lowest() RT_NOEXCEPT { return false; }
148 static constexpr bool epsilon() RT_NOEXCEPT { return false; }
149 static constexpr bool round_error() RT_NOEXCEPT { return false; }
150 static constexpr bool infinity() RT_NOEXCEPT { return false; }
151 static constexpr bool quiet_NaN() RT_NOEXCEPT { return false; }
152 static constexpr bool signaling_NaN() RT_NOEXCEPT { return false; }
153 static constexpr bool denorm_min() RT_NOEXCEPT { return false; }
154 static const int digits = 1;
155 };
156
157 template<>
158 struct numeric_limits<char> : public rtNoCrtLimitNumericIntBase
159 {
160 static constexpr char(min)() RT_NOEXCEPT { return CHAR_MIN; }
161 static constexpr char(max)() RT_NOEXCEPT { return CHAR_MAX; }
162 static constexpr char lowest() RT_NOEXCEPT { return CHAR_MIN; }
163 static constexpr char epsilon() RT_NOEXCEPT { return 0; }
164 static constexpr char round_error() RT_NOEXCEPT { return 0; }
165 static constexpr char infinity() RT_NOEXCEPT { return 0; }
166 static constexpr char quiet_NaN() RT_NOEXCEPT { return 0; }
167 static constexpr char signaling_NaN() RT_NOEXCEPT { return 0; }
168 static constexpr char denorm_min() RT_NOEXCEPT { return 0; }
169
170 static const bool is_signed = (char)(-1) < 0;
171 static const bool is_modulo = (char)(-1) > 0;
172 static const int digits = (char)(-1) < 0 ? CHAR_BIT - 1 : CHAR_BIT;
173 static const int digits10 = 2;
174 };
175
176 template<>
177 struct numeric_limits<signed char> : public rtNoCrtLimitNumericIntBase
178 {
179 static constexpr signed char(min)() RT_NOEXCEPT { return SCHAR_MIN; }
180 static constexpr signed char(max)() RT_NOEXCEPT { return SCHAR_MAX; }
181 static constexpr signed char lowest() RT_NOEXCEPT { return SCHAR_MIN; }
182 static constexpr signed char epsilon() RT_NOEXCEPT { return 0; }
183 static constexpr signed char round_error() RT_NOEXCEPT { return 0; }
184 static constexpr signed char infinity() RT_NOEXCEPT { return 0; }
185 static constexpr signed char quiet_NaN() RT_NOEXCEPT { return 0; }
186 static constexpr signed char signaling_NaN() RT_NOEXCEPT { return 0; }
187 static constexpr signed char denorm_min() RT_NOEXCEPT { return 0; }
188
189 static const bool is_signed = true;
190 static const int digits = CHAR_BIT - 1;
191 static const int digits10 = 2;
192 };
193
194 template<>
195 struct numeric_limits<unsigned char> : public rtNoCrtLimitNumericIntBase
196 {
197 static constexpr unsigned char(min)() RT_NOEXCEPT { return 0; }
198 static constexpr unsigned char(max)() RT_NOEXCEPT { return UCHAR_MAX; }
199 static constexpr unsigned char lowest() RT_NOEXCEPT { return 0; }
200 static constexpr unsigned char epsilon() RT_NOEXCEPT { return 0; }
201 static constexpr unsigned char round_error() RT_NOEXCEPT { return 0; }
202 static constexpr unsigned char infinity() RT_NOEXCEPT { return 0; }
203 static constexpr unsigned char quiet_NaN() RT_NOEXCEPT { return 0; }
204 static constexpr unsigned char signaling_NaN() RT_NOEXCEPT { return 0; }
205 static constexpr unsigned char denorm_min() RT_NOEXCEPT { return 0; }
206
207 static const bool is_modulo = true;
208 static const int digits = CHAR_BIT;
209 static const int digits10 = 2;
210 };
211
212 /** @todo wchar_t, char8_t, char16_t, char32_t */
213
214 template<>
215 struct numeric_limits<short> : public rtNoCrtLimitNumericIntBase
216 {
217 static constexpr short(min)() RT_NOEXCEPT { return SHRT_MIN; }
218 static constexpr short(max)() RT_NOEXCEPT { return SHRT_MAX; }
219 static constexpr short lowest() RT_NOEXCEPT { return SHRT_MIN; }
220 static constexpr short epsilon() RT_NOEXCEPT { return 0; }
221 static constexpr short round_error() RT_NOEXCEPT { return 0; }
222 static constexpr short infinity() RT_NOEXCEPT { return 0; }
223 static constexpr short quiet_NaN() RT_NOEXCEPT { return 0; }
224 static constexpr short signaling_NaN() RT_NOEXCEPT { return 0; }
225 static constexpr short denorm_min() RT_NOEXCEPT { return 0; }
226
227 static const bool is_signed = true;
228 static const int digits = CHAR_BIT * sizeof(short) - 1;
229 static const int digits10 = 4;
230 };
231
232 template<>
233 struct numeric_limits<unsigned short> : public rtNoCrtLimitNumericIntBase
234 {
235 static constexpr unsigned short(min)() RT_NOEXCEPT { return 0; }
236 static constexpr unsigned short(max)() RT_NOEXCEPT { return USHRT_MAX; }
237 static constexpr unsigned short lowest() RT_NOEXCEPT { return 0; }
238 static constexpr unsigned short epsilon() RT_NOEXCEPT { return 0; }
239 static constexpr unsigned short round_error() RT_NOEXCEPT { return 0; }
240 static constexpr unsigned short infinity() RT_NOEXCEPT { return 0; }
241 static constexpr unsigned short quiet_NaN() RT_NOEXCEPT { return 0; }
242 static constexpr unsigned short signaling_NaN() RT_NOEXCEPT { return 0; }
243 static constexpr unsigned short denorm_min() RT_NOEXCEPT { return 0; }
244
245 static const bool is_modulo = true;
246 static const int digits = CHAR_BIT * sizeof(unsigned short);
247 static const int digits10 = 4;
248 };
249
250# if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
251 template<>
252 struct numeric_limits<wchar_t> : public rtNoCrtLimitNumericIntBase
253 {
254 static constexpr wchar_t(min)() RT_NOEXCEPT { return WCHAR_MIN; }
255 static constexpr wchar_t(max)() RT_NOEXCEPT { return WCHAR_MAX; }
256 static constexpr wchar_t lowest() RT_NOEXCEPT { return WCHAR_MIN; }
257 static constexpr wchar_t epsilon() RT_NOEXCEPT { return 0; }
258 static constexpr wchar_t round_error() RT_NOEXCEPT { return 0; }
259 static constexpr wchar_t infinity() RT_NOEXCEPT { return 0; }
260 static constexpr wchar_t quiet_NaN() RT_NOEXCEPT { return 0; }
261 static constexpr wchar_t signaling_NaN() RT_NOEXCEPT { return 0; }
262 static constexpr wchar_t denorm_min() RT_NOEXCEPT { return 0; }
263
264 static const bool is_modulo = true;
265 static const int digits = CHAR_BIT * sizeof(wchar_t);
266 static const int digits10 = sizeof(wchar_t) == 2 ? 4 : 9; /** @todo ASSUMES wchar_t is either 16 or 32 bits */
267 };
268# endif
269
270 template<>
271 struct numeric_limits<char16_t> : public rtNoCrtLimitNumericIntBase
272 {
273 static constexpr char16_t(min)() RT_NOEXCEPT { return 0; }
274 static constexpr char16_t(max)() RT_NOEXCEPT { return USHRT_MAX; }
275 static constexpr char16_t lowest() RT_NOEXCEPT { return 0; }
276 static constexpr char16_t epsilon() RT_NOEXCEPT { return 0; }
277 static constexpr char16_t round_error() RT_NOEXCEPT { return 0; }
278 static constexpr char16_t infinity() RT_NOEXCEPT { return 0; }
279 static constexpr char16_t quiet_NaN() RT_NOEXCEPT { return 0; }
280 static constexpr char16_t signaling_NaN() RT_NOEXCEPT { return 0; }
281 static constexpr char16_t denorm_min() RT_NOEXCEPT { return 0; }
282
283 static const bool is_modulo = true;
284 static const int digits = CHAR_BIT * sizeof(char16_t);
285 static const int digits10 = 4;
286 };
287
288 template<>
289 struct numeric_limits<int> : public rtNoCrtLimitNumericIntBase
290 {
291 static constexpr int(min)() RT_NOEXCEPT { return INT_MIN; }
292 static constexpr int(max)() RT_NOEXCEPT { return INT_MAX; }
293 static constexpr int lowest() RT_NOEXCEPT { return INT_MIN; }
294 static constexpr int epsilon() RT_NOEXCEPT { return 0; }
295 static constexpr int round_error() RT_NOEXCEPT { return 0; }
296 static constexpr int infinity() RT_NOEXCEPT { return 0; }
297 static constexpr int quiet_NaN() RT_NOEXCEPT { return 0; }
298 static constexpr int signaling_NaN() RT_NOEXCEPT { return 0; }
299 static constexpr int denorm_min() RT_NOEXCEPT { return 0; }
300
301 static const bool is_signed = true;
302 static const int digits = CHAR_BIT * sizeof(int) - 1;
303 static const int digits10 = 9;
304 };
305
306 template<>
307 struct numeric_limits<unsigned int> : public rtNoCrtLimitNumericIntBase
308 {
309 static constexpr unsigned int(min)() RT_NOEXCEPT { return 0; }
310 static constexpr unsigned int(max)() RT_NOEXCEPT { return UINT_MAX; }
311 static constexpr unsigned int lowest() RT_NOEXCEPT { return 0; }
312 static constexpr unsigned int epsilon() RT_NOEXCEPT { return 0; }
313 static constexpr unsigned int round_error() RT_NOEXCEPT { return 0; }
314 static constexpr unsigned int infinity() RT_NOEXCEPT { return 0; }
315 static constexpr unsigned int quiet_NaN() RT_NOEXCEPT { return 0; }
316 static constexpr unsigned int signaling_NaN() RT_NOEXCEPT { return 0; }
317 static constexpr unsigned int denorm_min() RT_NOEXCEPT { return 0; }
318
319 static const bool is_modulo = true;
320 static const int digits = CHAR_BIT * sizeof(unsigned int);
321 static const int digits10 = 9;
322 };
323
324 template<>
325 struct numeric_limits<char32_t> : public rtNoCrtLimitNumericIntBase
326 {
327 static constexpr char32_t(min)() RT_NOEXCEPT { return 0; }
328 static constexpr char32_t(max)() RT_NOEXCEPT { return UINT_MAX; }
329 static constexpr char32_t lowest() RT_NOEXCEPT { return 0; }
330 static constexpr char32_t epsilon() RT_NOEXCEPT { return 0; }
331 static constexpr char32_t round_error() RT_NOEXCEPT { return 0; }
332 static constexpr char32_t infinity() RT_NOEXCEPT { return 0; }
333 static constexpr char32_t quiet_NaN() RT_NOEXCEPT { return 0; }
334 static constexpr char32_t signaling_NaN() RT_NOEXCEPT { return 0; }
335 static constexpr char32_t denorm_min() RT_NOEXCEPT { return 0; }
336
337 static const bool is_modulo = true;
338 static const int digits = CHAR_BIT * sizeof(char32_t);
339 static const int digits10 = 9;
340 };
341
342 template<>
343 struct numeric_limits<long> : public rtNoCrtLimitNumericIntBase
344 {
345 static constexpr long(min)() RT_NOEXCEPT { return LONG_MIN; }
346 static constexpr long(max)() RT_NOEXCEPT { return LONG_MAX; }
347 static constexpr long lowest() RT_NOEXCEPT { return LONG_MIN; }
348 static constexpr long epsilon() RT_NOEXCEPT { return 0; }
349 static constexpr long round_error() RT_NOEXCEPT { return 0; }
350 static constexpr long infinity() RT_NOEXCEPT { return 0; }
351 static constexpr long quiet_NaN() RT_NOEXCEPT { return 0; }
352 static constexpr long signaling_NaN() RT_NOEXCEPT { return 0; }
353 static constexpr long denorm_min() RT_NOEXCEPT { return 0; }
354
355 static const bool is_signed = true;
356 static const int digits = CHAR_BIT * sizeof(long) - 1;
357 static const int digits10 = sizeof(long) == sizeof(int) ? 9 : 18;
358 };
359
360 template<>
361 struct numeric_limits<unsigned long> : public rtNoCrtLimitNumericIntBase
362 {
363 static constexpr unsigned long(min)() RT_NOEXCEPT { return 0; }
364 static constexpr unsigned long(max)() RT_NOEXCEPT { return ULONG_MAX; }
365 static constexpr unsigned long lowest() RT_NOEXCEPT { return 0; }
366 static constexpr unsigned long epsilon() RT_NOEXCEPT { return 0; }
367 static constexpr unsigned long round_error() RT_NOEXCEPT { return 0; }
368 static constexpr unsigned long infinity() RT_NOEXCEPT { return 0; }
369 static constexpr unsigned long quiet_NaN() RT_NOEXCEPT { return 0; }
370 static constexpr unsigned long signaling_NaN() RT_NOEXCEPT { return 0; }
371 static constexpr unsigned long denorm_min() RT_NOEXCEPT { return 0; }
372
373 static const bool is_modulo = true;
374 static const int digits = CHAR_BIT * sizeof(unsigned long);
375 static const int digits10 = sizeof(unsigned long) == sizeof(unsigned int) ? 9 : 19;
376 };
377
378 template<>
379 struct numeric_limits<long long> : public rtNoCrtLimitNumericIntBase
380 {
381 static constexpr long long(min)() RT_NOEXCEPT { return LLONG_MIN; }
382 static constexpr long long(max)() RT_NOEXCEPT { return LLONG_MAX; }
383 static constexpr long long lowest() RT_NOEXCEPT { return LLONG_MIN; }
384 static constexpr long long epsilon() RT_NOEXCEPT { return 0; }
385 static constexpr long long round_error() RT_NOEXCEPT { return 0; }
386 static constexpr long long infinity() RT_NOEXCEPT { return 0; }
387 static constexpr long long quiet_NaN() RT_NOEXCEPT { return 0; }
388 static constexpr long long signaling_NaN() RT_NOEXCEPT { return 0; }
389 static constexpr long long denorm_min() RT_NOEXCEPT { return 0; }
390
391 static const bool is_signed = true;
392 static const int digits = CHAR_BIT * sizeof(long long) - 1;
393 static const int digits10 = 18;
394 };
395
396 template<>
397 struct numeric_limits<unsigned long long> : public rtNoCrtLimitNumericIntBase
398 {
399 static constexpr unsigned long long(min)() RT_NOEXCEPT { return 0; }
400 static constexpr unsigned long long(max)() RT_NOEXCEPT { return ULLONG_MAX; }
401 static constexpr unsigned long long lowest() RT_NOEXCEPT { return 0; }
402 static constexpr unsigned long long epsilon() RT_NOEXCEPT { return 0; }
403 static constexpr unsigned long long round_error() RT_NOEXCEPT { return 0; }
404 static constexpr unsigned long long infinity() RT_NOEXCEPT { return 0; }
405 static constexpr unsigned long long quiet_NaN() RT_NOEXCEPT { return 0; }
406 static constexpr unsigned long long signaling_NaN() RT_NOEXCEPT { return 0; }
407 static constexpr unsigned long long denorm_min() RT_NOEXCEPT { return 0; }
408
409 static const bool is_modulo = true;
410 static const int digits = CHAR_BIT * sizeof(unsigned long long);
411 static const int digits10 = 19;
412 };
413
414
415 /*
416 * Floating point.
417 */
418 template<>
419 struct numeric_limits<float> : public rtNoCrtLimitNumericFloatBase
420 {
421 static constexpr float(min)() RT_NOEXCEPT { return FLT_MIN; }
422 static constexpr float(max)() RT_NOEXCEPT { return FLT_MAX; }
423 static constexpr float lowest() RT_NOEXCEPT { return -(FLT_MAX); }
424 static constexpr float epsilon() RT_NOEXCEPT { return FLT_EPSILON; }
425 static constexpr float round_error() RT_NOEXCEPT { return 0.5F; }
426 static constexpr float infinity() RT_NOEXCEPT { return __builtin_huge_valf(); }
427 static constexpr float quiet_NaN() RT_NOEXCEPT { return __builtin_nanf("0"); }
428 static constexpr float signaling_NaN() RT_NOEXCEPT { return __builtin_nansf("1"); }
429 static constexpr float denorm_min() RT_NOEXCEPT { return FLT_TRUE_MIN; }
430
431 static const int digits = FLT_MANT_DIG;
432 static const int digits10 = FLT_DIG;
433 static const int max_digits10 = FLT_DECIMAL_DIG;
434 static const int max_exponent = FLT_MAX_EXP;
435 static const int max_exponent10 = FLT_MAX_10_EXP;
436 static const int min_exponent = FLT_MIN_EXP;
437 static const int min_exponent10 = FLT_MIN_10_EXP;
438 };
439
440 template<>
441 struct numeric_limits<double> : public rtNoCrtLimitNumericFloatBase
442 {
443 static constexpr double(min)() RT_NOEXCEPT { return DBL_MIN; }
444 static constexpr double(max)() RT_NOEXCEPT { return DBL_MAX; }
445 static constexpr double lowest() RT_NOEXCEPT { return -(DBL_MAX); }
446 static constexpr double epsilon() RT_NOEXCEPT { return DBL_EPSILON; }
447 static constexpr double round_error() RT_NOEXCEPT { return 0.5; }
448 static constexpr double infinity() RT_NOEXCEPT { return __builtin_huge_val(); }
449 static constexpr double quiet_NaN() RT_NOEXCEPT { return __builtin_nan("0"); }
450 static constexpr double signaling_NaN() RT_NOEXCEPT { return __builtin_nans("1"); }
451 static constexpr double denorm_min() RT_NOEXCEPT { return DBL_TRUE_MIN; }
452
453 static const int digits = DBL_MANT_DIG;
454 static const int digits10 = DBL_DIG;
455 static const int max_digits10 = DBL_DECIMAL_DIG;
456 static const int max_exponent = DBL_MAX_EXP;
457 static const int max_exponent10 = DBL_MAX_10_EXP;
458 static const int min_exponent = DBL_MIN_EXP;
459 static const int min_exponent10 = DBL_MIN_10_EXP;
460 };
461
462 template<>
463 struct numeric_limits<long double> : public rtNoCrtLimitNumericFloatBase
464 {
465 static constexpr long double(min)() RT_NOEXCEPT { return LDBL_MIN; }
466 static constexpr long double(max)() RT_NOEXCEPT { return LDBL_MAX; }
467 static constexpr long double lowest() RT_NOEXCEPT { return -(LDBL_MAX); }
468 static constexpr long double epsilon() RT_NOEXCEPT { return LDBL_EPSILON; }
469 static constexpr long double round_error() RT_NOEXCEPT { return 0.5L; }
470#if LDBL_DIG == DBL_DIG
471 static constexpr long double infinity() RT_NOEXCEPT { return __builtin_huge_val(); }
472 static constexpr long double quiet_NaN() RT_NOEXCEPT { return __builtin_nan("0"); }
473 static constexpr long double signaling_NaN() RT_NOEXCEPT { return __builtin_nans("1"); }
474#else
475 static constexpr long double infinity() RT_NOEXCEPT { return __builtin_huge_vall(); }
476 static constexpr long double quiet_NaN() RT_NOEXCEPT { return __builtin_nanl("0"); }
477 static constexpr long double signaling_NaN() RT_NOEXCEPT { return __builtin_nansl("1"); }
478#endif
479 static constexpr long double denorm_min() RT_NOEXCEPT { return LDBL_TRUE_MIN; }
480
481 static const int digits = LDBL_MANT_DIG;
482 static const int digits10 = LDBL_DIG;
483 static const int max_digits10 = LDBL_DECIMAL_DIG;
484 static const int max_exponent = LDBL_MAX_EXP;
485 static const int max_exponent10 = LDBL_MAX_10_EXP;
486 static const int min_exponent = LDBL_MIN_EXP;
487 static const int min_exponent10 = LDBL_MIN_10_EXP;
488 };
489
490 /** @todo more types */
491}
492
493#endif /* !VBOX_INCLUDED_SRC_nocrt_limits */
494
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette