My Project
numeric_limits.hpp
Go to the documentation of this file.
1 
28 #ifndef BSL_NUMERIC_LIMITS_HPP
29 #define BSL_NUMERIC_LIMITS_HPP
30 
31 #include "climits.hpp"
32 #include "cstdint.hpp"
33 #include "float_denorm_style.hpp"
34 #include "float_round_style.hpp"
35 #include "is_unsigned.hpp"
36 
37 namespace bsl
38 {
39  namespace details
40  {
48  template<typename T>
49  [[nodiscard]] constexpr bsl::int32
50  get_digits() noexcept
51  {
52  if (is_unsigned<T>::value) {
53  return (CHAR_BIT * static_cast<bsl::int32>(sizeof(T)));
54  }
55 
56  return (CHAR_BIT * static_cast<bsl::int32>(sizeof(T))) - 1;
57  }
58  }
59 
69  template<typename T>
70  class numeric_limits final
71  {
73  static constexpr bool is_specialized{false};
75  static constexpr bool is_signed{false};
77  static constexpr bool is_integer{false};
79  static constexpr bool is_exact{false};
81  static constexpr bool has_infinity{false};
83  static constexpr bool has_quiet_NaN{false};
85  static constexpr bool has_signaling_NaN{false};
87  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
89  static constexpr bool has_denorm_loss{false};
91  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
93  static constexpr bool is_iec559{false};
95  static constexpr bool is_bounded{false};
97  static constexpr bool is_modulo{false};
99  static constexpr bsl::int32 digits{0};
101  static constexpr bsl::int32 digits10{0};
103  static constexpr bsl::int32 max_digits10{0};
105  static constexpr bsl::int32 radix{0};
107  static constexpr bsl::int32 min_exponent{0};
109  static constexpr bsl::int32 min_exponent10{0};
111  static constexpr bsl::int32 max_exponent{0};
113  static constexpr bsl::int32 max_exponent10{0};
115  static constexpr bool traps{false};
117  static constexpr bool tinyness_before{false};
118 
119  public:
127  static constexpr T
128  min() noexcept
129  {
130  return {};
131  }
132 
140  static constexpr T
141  lowest() noexcept
142  {
143  return {};
144  }
145 
153  static constexpr T
154  max() noexcept
155  {
156  return {};
157  }
158 
166  static constexpr T
167  epsilon() noexcept
168  {
169  return {};
170  }
171 
179  static constexpr T
180  round_error() noexcept
181  {
182  return {};
183  }
184 
192  static constexpr T
193  infinity() noexcept
194  {
195  return {};
196  }
197 
205  static constexpr T
206  quiet_NaN() noexcept
207  {
208  return {};
209  }
210 
218  static constexpr T
219  signaling_NaN() noexcept
220  {
221  return {};
222  }
223 
231  static constexpr T
232  denorm_min() noexcept
233  {
234  return {};
235  }
236  };
237 
239 
246  template<>
247  class numeric_limits<bool> final
248  {
250  static constexpr bool is_specialized{true};
252  static constexpr bool is_signed{false};
254  static constexpr bool is_integer{true};
256  static constexpr bool is_exact{true};
258  static constexpr bool has_infinity{false};
260  static constexpr bool has_quiet_NaN{false};
262  static constexpr bool has_signaling_NaN{false};
264  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
266  static constexpr bool has_denorm_loss{false};
268  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
270  static constexpr bool is_iec559{false};
272  static constexpr bool is_bounded{true};
274  static constexpr bool is_modulo{false};
276  static constexpr bsl::int32 digits{1};
278  static constexpr bsl::int32 digits10{0};
280  static constexpr bsl::int32 max_digits10{0};
282  static constexpr bsl::int32 radix{2};
284  static constexpr bsl::int32 min_exponent{0};
286  static constexpr bsl::int32 min_exponent10{0};
288  static constexpr bsl::int32 max_exponent{0};
290  static constexpr bsl::int32 max_exponent10{0};
292  static constexpr bool traps{false};
294  static constexpr bool tinyness_before{false};
295 
296  public:
304  static constexpr bool
305  min() noexcept
306  {
307  return false;
308  }
309 
317  static constexpr bool
318  lowest() noexcept
319  {
320  return false;
321  }
322 
330  static constexpr bool
331  max() noexcept
332  {
333  return true;
334  }
335 
343  static constexpr bool
344  epsilon() noexcept
345  {
346  return false;
347  }
348 
356  static constexpr bool
357  round_error() noexcept
358  {
359  return false;
360  }
361 
369  static constexpr bool
370  infinity() noexcept
371  {
372  return false;
373  }
374 
382  static constexpr bool
383  quiet_NaN() noexcept
384  {
385  return false;
386  }
387 
395  static constexpr bool
396  signaling_NaN() noexcept
397  {
398  return false;
399  }
400 
408  static constexpr bool
409  denorm_min() noexcept
410  {
411  return false;
412  }
413  };
414 
421  template<>
422  class numeric_limits<bsl::int8> final
423  {
425  static constexpr bool is_specialized{true};
427  static constexpr bool is_signed{true};
429  static constexpr bool is_integer{true};
431  static constexpr bool is_exact{true};
433  static constexpr bool has_infinity{false};
435  static constexpr bool has_quiet_NaN{false};
437  static constexpr bool has_signaling_NaN{false};
439  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
441  static constexpr bool has_denorm_loss{false};
443  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
445  static constexpr bool is_iec559{false};
447  static constexpr bool is_bounded{true};
449  static constexpr bool is_modulo{false};
451  static constexpr bsl::int32 digits{details::get_digits<bsl::int8>()};
453  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
455  static constexpr bsl::int32 max_digits10{0};
457  static constexpr bsl::int32 radix{2};
459  static constexpr bsl::int32 min_exponent{0};
461  static constexpr bsl::int32 min_exponent10{0};
463  static constexpr bsl::int32 max_exponent{0};
465  static constexpr bsl::int32 max_exponent10{0};
467  static constexpr bool traps{false};
469  static constexpr bool tinyness_before{false};
470 
471  public:
479  static constexpr bsl::int8
480  min() noexcept
481  {
482  return INT8_MIN;
483  }
484 
492  static constexpr bsl::int8
493  lowest() noexcept
494  {
495  return INT8_MIN;
496  }
497 
505  static constexpr bsl::int8
506  max() noexcept
507  {
508  return INT8_MAX;
509  }
510 
518  static constexpr bsl::int8
519  epsilon() noexcept
520  {
521  return 0;
522  }
523 
531  static constexpr bsl::int8
532  round_error() noexcept
533  {
534  return 0;
535  }
536 
544  static constexpr bsl::int8
545  infinity() noexcept
546  {
547  return 0;
548  }
549 
557  static constexpr bsl::int8
558  quiet_NaN() noexcept
559  {
560  return 0;
561  }
562 
570  static constexpr bsl::int8
571  signaling_NaN() noexcept
572  {
573  return 0;
574  }
575 
583  static constexpr bsl::int8
584  denorm_min() noexcept
585  {
586  return 0;
587  }
588  };
589 
596  template<>
597  class numeric_limits<bsl::int16> final
598  {
600  static constexpr bool is_specialized{true};
602  static constexpr bool is_signed{true};
604  static constexpr bool is_integer{true};
606  static constexpr bool is_exact{true};
608  static constexpr bool has_infinity{false};
610  static constexpr bool has_quiet_NaN{false};
612  static constexpr bool has_signaling_NaN{false};
614  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
616  static constexpr bool has_denorm_loss{false};
618  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
620  static constexpr bool is_iec559{false};
622  static constexpr bool is_bounded{true};
624  static constexpr bool is_modulo{false};
626  static constexpr bsl::int32 digits{details::get_digits<bsl::int16>()};
628  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
630  static constexpr bsl::int32 max_digits10{0};
632  static constexpr bsl::int32 radix{2};
634  static constexpr bsl::int32 min_exponent{0};
636  static constexpr bsl::int32 min_exponent10{0};
638  static constexpr bsl::int32 max_exponent{0};
640  static constexpr bsl::int32 max_exponent10{0};
642  static constexpr bool traps{false};
644  static constexpr bool tinyness_before{false};
645 
646  public:
654  static constexpr bsl::int16
655  min() noexcept
656  {
657  return INT16_MIN;
658  }
659 
667  static constexpr bsl::int16
668  lowest() noexcept
669  {
670  return INT16_MIN;
671  }
672 
680  static constexpr bsl::int16
681  max() noexcept
682  {
683  return INT16_MAX;
684  }
685 
693  static constexpr bsl::int16
694  epsilon() noexcept
695  {
696  return 0;
697  }
698 
706  static constexpr bsl::int16
707  round_error() noexcept
708  {
709  return 0;
710  }
711 
719  static constexpr bsl::int16
720  infinity() noexcept
721  {
722  return 0;
723  }
724 
732  static constexpr bsl::int16
733  quiet_NaN() noexcept
734  {
735  return 0;
736  }
737 
745  static constexpr bsl::int16
746  signaling_NaN() noexcept
747  {
748  return 0;
749  }
750 
758  static constexpr bsl::int16
759  denorm_min() noexcept
760  {
761  return 0;
762  }
763  };
764 
771  template<>
772  class numeric_limits<bsl::int32> final
773  {
775  static constexpr bool is_specialized{true};
777  static constexpr bool is_signed{true};
779  static constexpr bool is_integer{true};
781  static constexpr bool is_exact{true};
783  static constexpr bool has_infinity{false};
785  static constexpr bool has_quiet_NaN{false};
787  static constexpr bool has_signaling_NaN{false};
789  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
791  static constexpr bool has_denorm_loss{false};
793  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
795  static constexpr bool is_iec559{false};
797  static constexpr bool is_bounded{true};
799  static constexpr bool is_modulo{false};
801  static constexpr bsl::int32 digits{details::get_digits<bsl::int32>()};
803  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
805  static constexpr bsl::int32 max_digits10{0};
807  static constexpr bsl::int32 radix{2};
809  static constexpr bsl::int32 min_exponent{0};
811  static constexpr bsl::int32 min_exponent10{0};
813  static constexpr bsl::int32 max_exponent{0};
815  static constexpr bsl::int32 max_exponent10{0};
817  static constexpr bool traps{false};
819  static constexpr bool tinyness_before{false};
820 
821  public:
829  static constexpr bsl::int32
830  min() noexcept
831  {
832  return INT32_MIN;
833  }
834 
842  static constexpr bsl::int32
843  lowest() noexcept
844  {
845  return INT32_MIN;
846  }
847 
855  static constexpr bsl::int32
856  max() noexcept
857  {
858  return INT32_MAX;
859  }
860 
868  static constexpr bsl::int32
869  epsilon() noexcept
870  {
871  return 0;
872  }
873 
881  static constexpr bsl::int32
882  round_error() noexcept
883  {
884  return 0;
885  }
886 
894  static constexpr bsl::int32
895  infinity() noexcept
896  {
897  return 0;
898  }
899 
907  static constexpr bsl::int32
908  quiet_NaN() noexcept
909  {
910  return 0;
911  }
912 
920  static constexpr bsl::int32
921  signaling_NaN() noexcept
922  {
923  return 0;
924  }
925 
933  static constexpr bsl::int32
934  denorm_min() noexcept
935  {
936  return 0;
937  }
938  };
939 
946  template<>
947  class numeric_limits<bsl::int64> final
948  {
950  static constexpr bool is_specialized{true};
952  static constexpr bool is_signed{true};
954  static constexpr bool is_integer{true};
956  static constexpr bool is_exact{true};
958  static constexpr bool has_infinity{false};
960  static constexpr bool has_quiet_NaN{false};
962  static constexpr bool has_signaling_NaN{false};
964  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
966  static constexpr bool has_denorm_loss{false};
968  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
970  static constexpr bool is_iec559{false};
972  static constexpr bool is_bounded{true};
974  static constexpr bool is_modulo{false};
976  static constexpr bsl::int32 digits{details::get_digits<bsl::int64>()};
978  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
980  static constexpr bsl::int32 max_digits10{0};
982  static constexpr bsl::int32 radix{2};
984  static constexpr bsl::int32 min_exponent{0};
986  static constexpr bsl::int32 min_exponent10{0};
988  static constexpr bsl::int32 max_exponent{0};
990  static constexpr bsl::int32 max_exponent10{0};
992  static constexpr bool traps{false};
994  static constexpr bool tinyness_before{false};
995 
996  public:
1004  static constexpr bsl::int64
1005  min() noexcept
1006  {
1007  return INT64_MIN;
1008  }
1009 
1017  static constexpr bsl::int64
1018  lowest() noexcept
1019  {
1020  return INT64_MIN;
1021  }
1022 
1030  static constexpr bsl::int64
1031  max() noexcept
1032  {
1033  return INT64_MAX;
1034  }
1035 
1043  static constexpr bsl::int64
1044  epsilon() noexcept
1045  {
1046  return 0;
1047  }
1048 
1056  static constexpr bsl::int64
1057  round_error() noexcept
1058  {
1059  return 0;
1060  }
1061 
1069  static constexpr bsl::int64
1070  infinity() noexcept
1071  {
1072  return 0;
1073  }
1074 
1082  static constexpr bsl::int64
1083  quiet_NaN() noexcept
1084  {
1085  return 0;
1086  }
1087 
1095  static constexpr bsl::int64
1096  signaling_NaN() noexcept
1097  {
1098  return 0;
1099  }
1100 
1108  static constexpr bsl::int64
1109  denorm_min() noexcept
1110  {
1111  return 0;
1112  }
1113  };
1114 
1121  template<>
1122  class numeric_limits<bsl::uint8> final
1123  {
1125  static constexpr bool is_specialized{true};
1127  static constexpr bool is_signed{false};
1129  static constexpr bool is_integer{true};
1131  static constexpr bool is_exact{true};
1133  static constexpr bool has_infinity{false};
1135  static constexpr bool has_quiet_NaN{false};
1137  static constexpr bool has_signaling_NaN{false};
1139  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
1141  static constexpr bool has_denorm_loss{false};
1143  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
1145  static constexpr bool is_iec559{false};
1147  static constexpr bool is_bounded{true};
1149  static constexpr bool is_modulo{true};
1151  static constexpr bsl::int32 digits{details::get_digits<bsl::uint8>()};
1153  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
1155  static constexpr bsl::int32 max_digits10{0};
1157  static constexpr bsl::int32 radix{2};
1159  static constexpr bsl::int32 min_exponent{0};
1161  static constexpr bsl::int32 min_exponent10{0};
1163  static constexpr bsl::int32 max_exponent{0};
1165  static constexpr bsl::int32 max_exponent10{0};
1167  static constexpr bool traps{false};
1169  static constexpr bool tinyness_before{false};
1170 
1171  public:
1179  static constexpr bsl::uint8
1180  min() noexcept
1181  {
1182  return 0U;
1183  }
1184 
1192  static constexpr bsl::uint8
1193  lowest() noexcept
1194  {
1195  return 0U;
1196  }
1197 
1210  static constexpr bsl::uint8
1211  max() noexcept
1212  {
1213  return UINT8_MAX; // PRQA S 1-10000
1214  }
1215 
1223  static constexpr bsl::uint8
1224  epsilon() noexcept
1225  {
1226  return 0U;
1227  }
1228 
1236  static constexpr bsl::uint8
1237  round_error() noexcept
1238  {
1239  return 0U;
1240  }
1241 
1249  static constexpr bsl::uint8
1250  infinity() noexcept
1251  {
1252  return 0U;
1253  }
1254 
1262  static constexpr bsl::uint8
1263  quiet_NaN() noexcept
1264  {
1265  return 0U;
1266  }
1267 
1275  static constexpr bsl::uint8
1276  signaling_NaN() noexcept
1277  {
1278  return 0U;
1279  }
1280 
1288  static constexpr bsl::uint8
1289  denorm_min() noexcept
1290  {
1291  return 0U;
1292  }
1293  };
1294 
1301  template<>
1302  class numeric_limits<bsl::uint16> final
1303  {
1305  static constexpr bool is_specialized{true};
1307  static constexpr bool is_signed{false};
1309  static constexpr bool is_integer{true};
1311  static constexpr bool is_exact{true};
1313  static constexpr bool has_infinity{false};
1315  static constexpr bool has_quiet_NaN{false};
1317  static constexpr bool has_signaling_NaN{false};
1319  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
1321  static constexpr bool has_denorm_loss{false};
1323  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
1325  static constexpr bool is_iec559{false};
1327  static constexpr bool is_bounded{true};
1329  static constexpr bool is_modulo{true};
1331  static constexpr bsl::int32 digits{details::get_digits<bsl::uint16>()};
1333  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
1335  static constexpr bsl::int32 max_digits10{0};
1337  static constexpr bsl::int32 radix{2};
1339  static constexpr bsl::int32 min_exponent{0};
1341  static constexpr bsl::int32 min_exponent10{0};
1343  static constexpr bsl::int32 max_exponent{0};
1345  static constexpr bsl::int32 max_exponent10{0};
1347  static constexpr bool traps{false};
1349  static constexpr bool tinyness_before{false};
1350 
1351  public:
1359  static constexpr bsl::uint16
1360  min() noexcept
1361  {
1362  return 0U;
1363  }
1364 
1372  static constexpr bsl::uint16
1373  lowest() noexcept
1374  {
1375  return 0U;
1376  }
1377 
1390  static constexpr bsl::uint16
1391  max() noexcept
1392  {
1393  return UINT16_MAX; // PRQA S 1-10000
1394  }
1395 
1403  static constexpr bsl::uint16
1404  epsilon() noexcept
1405  {
1406  return 0U;
1407  }
1408 
1416  static constexpr bsl::uint16
1417  round_error() noexcept
1418  {
1419  return 0U;
1420  }
1421 
1429  static constexpr bsl::uint16
1430  infinity() noexcept
1431  {
1432  return 0U;
1433  }
1434 
1442  static constexpr bsl::uint16
1443  quiet_NaN() noexcept
1444  {
1445  return 0U;
1446  }
1447 
1455  static constexpr bsl::uint16
1456  signaling_NaN() noexcept
1457  {
1458  return 0U;
1459  }
1460 
1468  static constexpr bsl::uint16
1469  denorm_min() noexcept
1470  {
1471  return 0U;
1472  }
1473  };
1474 
1481  template<>
1482  class numeric_limits<bsl::uint32> final
1483  {
1485  static constexpr bool is_specialized{true};
1487  static constexpr bool is_signed{false};
1489  static constexpr bool is_integer{true};
1491  static constexpr bool is_exact{true};
1493  static constexpr bool has_infinity{false};
1495  static constexpr bool has_quiet_NaN{false};
1497  static constexpr bool has_signaling_NaN{false};
1499  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
1501  static constexpr bool has_denorm_loss{false};
1503  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
1505  static constexpr bool is_iec559{false};
1507  static constexpr bool is_bounded{true};
1509  static constexpr bool is_modulo{true};
1511  static constexpr bsl::int32 digits{details::get_digits<bsl::uint32>()};
1513  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
1515  static constexpr bsl::int32 max_digits10{0};
1517  static constexpr bsl::int32 radix{2};
1519  static constexpr bsl::int32 min_exponent{0};
1521  static constexpr bsl::int32 min_exponent10{0};
1523  static constexpr bsl::int32 max_exponent{0};
1525  static constexpr bsl::int32 max_exponent10{0};
1527  static constexpr bool traps{false};
1529  static constexpr bool tinyness_before{false};
1530 
1531  public:
1539  static constexpr bsl::uint32
1540  min() noexcept
1541  {
1542  return 0U;
1543  }
1544 
1552  static constexpr bsl::uint32
1553  lowest() noexcept
1554  {
1555  return 0U;
1556  }
1557 
1565  static constexpr bsl::uint32
1566  max() noexcept
1567  {
1568  return UINT32_MAX;
1569  }
1570 
1578  static constexpr bsl::uint32
1579  epsilon() noexcept
1580  {
1581  return 0U;
1582  }
1583 
1591  static constexpr bsl::uint32
1592  round_error() noexcept
1593  {
1594  return 0U;
1595  }
1596 
1604  static constexpr bsl::uint32
1605  infinity() noexcept
1606  {
1607  return 0U;
1608  }
1609 
1617  static constexpr bsl::uint32
1618  quiet_NaN() noexcept
1619  {
1620  return 0U;
1621  }
1622 
1630  static constexpr bsl::uint32
1631  signaling_NaN() noexcept
1632  {
1633  return 0U;
1634  }
1635 
1643  static constexpr bsl::uint32
1644  denorm_min() noexcept
1645  {
1646  return 0U;
1647  }
1648  };
1649 
1656  template<>
1657  class numeric_limits<bsl::uint64> final
1658  {
1660  static constexpr bool is_specialized{true};
1662  static constexpr bool is_signed{false};
1664  static constexpr bool is_integer{true};
1666  static constexpr bool is_exact{true};
1668  static constexpr bool has_infinity{false};
1670  static constexpr bool has_quiet_NaN{false};
1672  static constexpr bool has_signaling_NaN{false};
1674  static constexpr float_denorm_style has_denorm{float_denorm_style::denorm_absent};
1676  static constexpr bool has_denorm_loss{false};
1678  static constexpr float_round_style round_style{float_round_style::round_toward_zero};
1680  static constexpr bool is_iec559{false};
1682  static constexpr bool is_bounded{true};
1684  static constexpr bool is_modulo{true};
1686  static constexpr bsl::int32 digits{details::get_digits<bsl::uint64>()};
1688  static constexpr bsl::int32 digits10{0}; // TODO... need to sort out the need for log10
1690  static constexpr bsl::int32 max_digits10{0};
1692  static constexpr bsl::int32 radix{2};
1694  static constexpr bsl::int32 min_exponent{0};
1696  static constexpr bsl::int32 min_exponent10{0};
1698  static constexpr bsl::int32 max_exponent{0};
1700  static constexpr bsl::int32 max_exponent10{0};
1702  static constexpr bool traps{false};
1704  static constexpr bool tinyness_before{false};
1705 
1706  public:
1714  static constexpr bsl::uint64
1715  min() noexcept
1716  {
1717  return 0U;
1718  }
1719 
1727  static constexpr bsl::uint64
1728  lowest() noexcept
1729  {
1730  return 0U;
1731  }
1732 
1740  static constexpr bsl::uint64
1741  max() noexcept
1742  {
1743  return UINT64_MAX;
1744  }
1745 
1753  static constexpr bsl::uint64
1754  epsilon() noexcept
1755  {
1756  return 0U;
1757  }
1758 
1766  static constexpr bsl::uint64
1767  round_error() noexcept
1768  {
1769  return 0U;
1770  }
1771 
1779  static constexpr bsl::uint64
1780  infinity() noexcept
1781  {
1782  return 0U;
1783  }
1784 
1792  static constexpr bsl::uint64
1793  quiet_NaN() noexcept
1794  {
1795  return 0U;
1796  }
1797 
1805  static constexpr bsl::uint64
1806  signaling_NaN() noexcept
1807  {
1808  return 0U;
1809  }
1810 
1818  static constexpr bsl::uint64
1819  denorm_min() noexcept
1820  {
1821  return 0U;
1822  }
1823  };
1824 
1826 }
1827 
1828 #endif
bsl::uint8
::uint8_t uint8
defines an 8bit unsigned integer
Definition: cstdint.hpp:45
float_round_style.hpp
bsl::numeric_limits::lowest
static constexpr T lowest() noexcept
Returns the lowest value of T.
Definition: numeric_limits.hpp:141
bsl::numeric_limits::epsilon
static constexpr T epsilon() noexcept
Returns the floating point resolution.
Definition: numeric_limits.hpp:167
bsl::uint16
::uint16_t uint16
defines an 16bit unsigned integer
Definition: cstdint.hpp:47
bsl::is_signed
If the provided type is a signed type (taking into account const qualifications), provides the member...
Definition: is_signed.hpp:56
bsl::int64
::int64_t int64
defines an 64bit signed integer
Definition: cstdint.hpp:42
bsl::is_unsigned
If the provided type is a unsigned type (taking into account const qualifications),...
Definition: is_unsigned.hpp:55
bsl::int16
::int16_t int16
defines an 16bit signed integer
Definition: cstdint.hpp:38
bsl::numeric_limits::denorm_min
static constexpr T denorm_min() noexcept
Returns the smallest subnormal value for T.
Definition: numeric_limits.hpp:232
bsl::uint32
::uint32_t uint32
defines an 32bit unsigned integer
Definition: cstdint.hpp:49
bsl::numeric_limits::quiet_NaN
static constexpr T quiet_NaN() noexcept
Returns the quiet NaN value for T.
Definition: numeric_limits.hpp:206
bsl::numeric_limits::signaling_NaN
static constexpr T signaling_NaN() noexcept
Returns the signaling NaN value for T.
Definition: numeric_limits.hpp:219
bsl::numeric_limits::min
static constexpr T min() noexcept
Returns the min value of T.
Definition: numeric_limits.hpp:128
bsl::int8
::int8_t int8
defines an 8bit signed integer
Definition: cstdint.hpp:36
bsl::details::get_digits
constexpr bsl::int32 get_digits() noexcept
Returns the number of Radix digits for a given type.
Definition: numeric_limits.hpp:50
bsl::numeric_limits::max
static constexpr T max() noexcept
Returns the max value of T.
Definition: numeric_limits.hpp:154
float_denorm_style.hpp
bsl::int32
::int32_t int32
defines an 32bit signed integer
Definition: cstdint.hpp:40
is_unsigned.hpp
bsl::float_round_style
float_round_style
Enumerates round styles for floating points.
Definition: float_round_style.hpp:46
bsl::uint64
::uint64_t uint64
defines an 64bit unsigned integer
Definition: cstdint.hpp:51
bsl::numeric_limits
Implements std::numeric_limits.
Definition: numeric_limits.hpp:70
bsl::numeric_limits::infinity
static constexpr T infinity() noexcept
Returns the value of infinity for T.
Definition: numeric_limits.hpp:193
bsl::float_denorm_style
float_denorm_style
Enumerates subnormal values for floating points.
Definition: float_denorm_style.hpp:46
bsl::numeric_limits::round_error
static constexpr T round_error() noexcept
Returns the rounding error of T.
Definition: numeric_limits.hpp:180
Generated by   doxygen 1.8.15