/* * * Copyright (C) 2014, OFFIS e.V. * All rights reserved. See COPYRIGHT file for details. * * This software and supporting documentation were developed by * * OFFIS e.V. * R&D Division Health * Escherweg 2 * D-26121 Oldenburg, Germany * * * Module: ofstd * * Author: Jan Schlamelcher * * Purpose: * Implementing C++11's numeric limits for old compilers. * */ #ifndef OFLIMITS_H #define OFLIMITS_H #include "dcmtk/config/osconfig.h" // make sure OS specific configuration is included first #include "dcmtk/config/arith.h" #include "dcmtk/ofstd/oftypes.h" // include this file in doxygen documentation /** @file oflimits.h * @brief Provides an interface to query properties of all fundamental numeric types. */ // use native classes if C++11 is supported #if __cplusplus >= 201103L #include using OFfloat_round_style = std::float_round_style; enum { OFround_indeterminate = std::round_indeterminate, OFround_toward_zero = std::round_toward_zero, OFround_to_nearest = std::round_to_nearest, OFround_toward_infinity = std::round_toward_infinity, OFround_toward_neg_infinity = std::round_toward_neg_infinity }; using OFfloat_denorm_style = std::float_denorm_style; enum { OFdenorm_indeterminate = std::denorm_indeterminate, OFdenorm_absent = std::denorm_absent, OFdenorm_present = std::denorm_present }; template using OFnumeric_limits = std::numeric_limits; #else // fallback implementations #define INCLUDE_CLIMITS #define INCLUDE_CFLOAT #define INCLUDE_CMATH #include "dcmtk/ofstd/ofstdinc.h" /** Enumeration constants of type OFfloat_round_style indicate the rounding style * used by floating-point arithmetics whenever a result of an expression is stored * in an object of a floating-point type. */ enum OFfloat_round_style { /// Rounding style cannot be determined OFround_indeterminate = -1, /// Rounding toward zero OFround_toward_zero = 0, /// Rounding toward nearest representable value OFround_to_nearest = 1, /// Rounding toward positive infinity OFround_toward_infinity = 2, /// Rounding toward negative infinity OFround_toward_neg_infinity = 3 }; /** Enumeration constants of type OFfloat_denorm_style indicate support of * subnormal values by floating-point types. */ enum OFfloat_denorm_style { /// Support of subnormal values cannot be determined OFdenorm_indeterminate = -1, /// The type does not support subnormal values OFdenorm_absent = 0, /// The type allows subnormal values OFdenorm_present = 1 }; #ifdef DOXYGEN /** A meta-template for querying various properties of fundamental types. * @headerfile oflimits.h "dcmtk/ofstd/oflimits.h" * @details * The template OFnumeric_limits provides a standardized way to query various * properties of fundamental types (e.g. the largest possible value for type * int is OFnumeric_limits::max()). * OFnumeric_limits is compatible to C++11's std::numeric_limits. * @tparam T The type to inspect. */ template struct OFnumeric_limits { /** OFTrue for all T for which there exists a * specialization of OFnumeric_limits, OFFalse * otherwise. *

C++11 standard definitions used:

* T | %is_specialized * ----------------------- | -------------- * non-specialized | OFFalse * OFBool | OFTrue * char | OFTrue * signed char | OFTrue * unsigned char | OFTrue * signed short | OFTrue * unsigned short | OFTrue * signed int | OFTrue * unsigned int | OFTrue * signed long | OFTrue * unsigned long | OFTrue * float | OFTrue * double | OFTrue */ static const OFBool is_specialized; /** OFTrue for all signed arithmetic types T and * OFFalse for the unsigned types. *

C++11 standard definitions used:

* T | %is_signed * ----------------------- | -------------- * non-specialized | OFFalse * OFBool | OFFalse * char | platform / compiler specific * signed char | OFTrue * unsigned char | OFFalse * signed short | OFTrue * unsigned short | OFFalse * signed int | OFTrue * unsigned int | OFFalse * signed long | OFTrue * unsigned long | OFFalse * float | OFTrue * double | OFTrue */ static const OFBool is_signed; /** OFTrue for all integer arithmetic types T and * OFFalse otherwise. *

C++11 standard definitions used:

* T | %is_integer * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFTrue * char | OFTrue * signed char | OFTrue * unsigned char | OFTrue * signed short | OFTrue * unsigned short | OFTrue * signed int | OFTrue * unsigned int | OFTrue * signed long | OFTrue * unsigned long | OFTrue * float | OFFalse * double | OFFalse */ static const OFBool is_integer; /** OFTrue for all arithmetic types T that use exact * representation. * @note While all fundamental types T for which * OFnumeric_limits::is_exact == OFTrue are integer * types, a library may define exact types that aren't integers, * e.g. a rational arithmetics type representing fractions. * @details *

C++11 standard definitions used:

* T | %is_exact * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFTrue * char | OFTrue * signed char | OFTrue * unsigned char | OFTrue * signed short | OFTrue * unsigned short | OFTrue * signed int | OFTrue * unsigned int | OFTrue * signed long | OFTrue * unsigned long | OFTrue * float | OFFalse * double | OFFalse */ static const OFBool is_exact; /** OFTrue for all types T capable of representing * the positive infinity as a distinct special value. * @note This constant is meaningful for all * floating-point types and is guaranteed to be OFTrue if * OFnumeric_limits::is_iec559 == OFTrue. * @details *

C++11 standard definitions used:

* T | %has_infinity * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | usually OFTrue * double | usually OFTrue */ static const OFBool has_infinity; /** OFTrue for all types T capable of representing * the special value Quiet Not-A-Number. * @note This constant is meaningful for all * floating-point types and is guaranteed to be OFTrue if * OFnumeric_limits::is_iec559 == OFTrue. * @details *

C++11 standard definitions used:

* T | %has_quit_NaN * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | usually OFTrue * double | usually OFTrue */ static const OFBool has_quiet_NaN; /** OFTrue for all types T capable of representing * the special value Signaling Not-A-Number. * @note This constant is meaningful for all floating-point types * and is guaranteed to be OFTrue if * OFnumeric_limits::is_iec559 == OFTrue. * @details *

C++11 standard definitions used:

* T | %has_signaling_NaN * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | usually OFTrue * double | usually OFTrue */ static const OFBool has_signaling_NaN; /** Identifies the floating-point types that support subnormal values. *

C++11 standard definitions used:

* T | %has_denorm * ----------------------- | ---------------------------- * non-specialized | OFdenorm_absent * OFBool | OFdenorm_absent * char | OFdenorm_absent * signed char | OFdenorm_absent * unsigned char | OFdenorm_absent * signed short | OFdenorm_absent * unsigned short | OFdenorm_absent * signed int | OFdenorm_absent * unsigned int | OFdenorm_absent * signed long | OFdenorm_absent * unsigned long | OFdenorm_absent * float | usually OFdenorm_present * double | usually OFdenorm_present */ static const OFfloat_denorm_style has_denorm; /** OFTrue for all floating-point types T capable of * distinguishing loss of precision due to denormalization from other * causes of inexact result. * @note Standard-compliant IEEE 754 floating-point implementations may * detect the floating-point underflow at three predefined moments: * 1. after computation of a result with absolute value smaller than * OFnumeric_limits::min(), such implementation detects * tinyness before rounding. * 2. after rounding of the result to OFnumeric_limits::digits * bits, if the result is tiny, such implementation detects tinyness * after rounding. * 3. if the conversion of the rounded tiny result to subnormal form * resulted in the loss of precision, such implementation detects * denorm loss. * @details *

C++11 standard definitions used:

* T | %has_denorm_loss * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | platform / compiler specific * double | platform / compiler specific */ static const OFBool has_denorm_loss; /** Identifies the rounding style used by the floating-point type T whenever * a value that is not one of the exactly representable values of T is stored * in an object of that type. *

C++11 standard definitions used:

* T | %round_style * ---------------------- | ---------------------------- * non-specialized | OFround_toward_zero * OFBool | OFround_toward_zero * char | OFround_toward_zero * signed char | OFround_toward_zero * unsigned char | OFround_toward_zero * signed short | OFround_toward_zero * unsigned short | OFround_toward_zero * signed int | OFround_toward_zero * unsigned int | OFround_toward_zero * signed long | OFround_toward_zero * unsigned long | OFround_toward_zero * float | usually OFround_to_nearest * double | usually OFround_to_nearest */ static const OFfloat_round_style round_style; /** OFTrue for all floating-point types T which fulfill the * requirements of IEC 559 (IEEE 754) standard. * @note If * OFnumeric_limits::is_iec559 == OFTrue, * then OFnumeric_limits::has_infinity, * OFnumeric_limits::has_quiet_NaN, and * OFnumeric_limits::has_signaling_NaN are also OFTrue. * @details *

C++11 standard definitions used:

* T | %is_iec559 * ----------------------- | ---------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | usually OFTrue * double | usually OFTrue */ static const OFBool is_iec559; /** OFTrue for all arithmetic types T that represent a * finite set of values. * @note While all fundamental types are bounded, this constant would be * OFFalse in a specialization of OFnumeric_limits * for a library-provided arbitrary precision arithmetic type. * @details *

C++11 standard definitions used:

* T | %is_bounded * ----------------------- | -------------- * non-specialized | OFFalse * OFBool | OFTrue * char | OFTrue * signed char | OFTrue * unsigned char | OFTrue * signed short | OFTrue * unsigned short | OFTrue * signed int | OFTrue * unsigned int | OFTrue * signed long | OFTrue * unsigned long | OFTrue * float | OFTrue * double | OFTrue */ static const OFBool is_bounded; /** OFTrue for all arithmetic types T that handle overflows * with modulo arithmetic, that is, if the result of addition, subtraction, * multiplication, or division of this type would fall outside the * range @f$[min(), max()]@f$, the value returned by such operation * differs from the expected value by a multiple of @f$max()-min() + 1@f$. * @details *

C++11 standard definitions used:

* T | %is_modulo * ----------------------- | -------------- * non-specialized | OFFalse * OFBool | OFFalse * char | platform / compiler specific * signed char | platform / compiler specific * unsigned char | OFTrue * signed short | platform / compiler specific * unsigned short | OFTrue * signed int | platform / compiler specific * unsigned int | OFTrue * signed long | platform / compiler specific * unsigned long | OFTrue * float | OFFalse * double | OFFalse */ static const OFBool is_modulo; /** The number of digits in base-radix that can be represented by the * type T without change. For integer types, this is the * number of bits not counting the sign bit. * For floating-point types, this is the number of digits in the * mantissa. * @details *

C++11 standard definitions used:

* T | %digits * ----------------------- | -------------- * non-specialized | 0 * OFBool | 1 * char | is_signed() ? CHAR_BIT : CHAR_BIT - 1 * signed char | CHAR_BIT - 1 * unsigned char | CHAR_BIT * signed short | CHAR_BIT * sizeof(signed short) - 1 * unsigned short | CHAR_BIT * sizeof(unsigned short) * signed int | CHAR_BIT * sizeof(signed int) - 1 * unsigned int | CHAR_BIT * sizeof(unsigned int) * signed long | CHAR_BIT * sizeof(signed long) - 1 * unsigned long | CHAR_BIT * sizeof(unsigned long) * float | FLT_MANT_DIG * double | DBL_MANT_DIG */ static const int digits; /** The number of base-10 digits that can be represented by the type T * without change, that is, any number with this many decimal digits can * be converted to a value of type T and back to decimal form, without * change due to rounding or overflow. For base-radix types, it is the * value of digits (digits-1 for floating-point types) multiplied by * @f$log_{10}(radix)@f$ and rounded down. * @details *

C++11 standard definitions used:

* T | %digits10 * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | @f$digits \cdot log_{10}(2)@f$ * signed char | @f$digits \cdot log_{10}(2)@f$ * unsigned char | @f$digits \cdot log_{10}(2)@f$ * signed short | @f$digits \cdot log_{10}(2)@f$ * unsigned short | @f$digits \cdot log_{10}(2)@f$ * signed int | @f$digits \cdot log_{10}(2)@f$ * unsigned int | @f$digits \cdot log_{10}(2)@f$ * signed long | @f$digits \cdot log_{10}(2)@f$ * unsigned long | @f$digits \cdot log_{10}(2)@f$ * float | FLT_DIG * double | DBL_DIG */ static const int digits10; /** The number of base-10 digits that are necessary to uniquely * represent all distinct values of the type T, such as * necessary for serialization/deserialization to text. * @note This constant is meaningful for all floating-point * types. * @details *

C++11 standard definitions used:

* T | %max_digits10 * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | @f$\lfloor digits \cdot log_{10}(2) + 2 \rfloor@f$ * double | @f$\lfloor digits \cdot log_{10}(2) + 2 \rfloor@f$ */ static const int max_digits10; /** The base of the number system used in the representation of the type. * It is 2 for all binary numeric types, but it may be, for example, * 10 for IEEE 754 decimal floating-point types or for third-party * binary-coded decimal integers. This constant is meaningful for * all specializations. * @details *

C++11 standard definitions used:

* T | %radix * ----------------------- | -------------- * non-specialized | 0 * OFBool | 2 * char | 2 * signed char | 2 * unsigned char | 2 * signed short | 2 * unsigned short | 2 * signed int | 2 * unsigned int | 2 * signed long | 2 * unsigned long | 2 * float | FLT_RADIX * double | FLT_RADIX */ static const int radix; /** The lowest negative number @f$n@f$ such that @f$radix^{n-1}@f$ is a * valid normalized value of the floating-point type T. * @details *

C++11 standard definitions used:

* T | %min_exponent * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | FLT_MIN_EXP * double | DBL_MIN_EXP */ static const int min_exponent; /** The lowest negative number @f$n@f$ such that @f$10^n@f$ is a valid * normalized value of the floating-point type T. * @details *

C++11 standard definitions used:

* T | %min_exponent10 * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | FLT_MIN_10_EXP * double | DBL_MIN_10_EXP */ static const int min_exponent10; /** The largest positive number @f$n@f$ such that @f$radix^{n-1}@f$ is a * valid normalized value of the floating-point type T. * @details *

C++11 standard definitions used:

* T | %max_exponent * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | FLT_MAX_EXP * double | DBL_MAX_EXP */ static const int max_exponent; /** The largest positive number @f$n@f$ such that @f$10^n@f$ is a valid * normalized value of the floating-point type T. * @details *

C++11 standard definitions used:

* T | %max_exponent10 * ----------------------- | -------------- * non-specialized | 0 * OFBool | 0 * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | FLT_MAX_10_EXP * double | DBL_MAX_10_EXP */ static const int max_exponent10; /** OFTrue for all arithmetic types T that have at least * one value that, if used as an argument to an arithmetic operation, will * generate a trap. * @note On most platforms integer division by zero always traps, * and OFnumeric_limits::traps is OFTrue for all * integer types that support the value 0. The exception is the * type OFBool, if support for the native type bool is available: * even though division by OFFalse traps due to integral promotion * from OFBool to int, it is the zero-valued int that traps. * Zero is not a value of type bool. * @note On most platforms, floating-point exceptions may be turned on and off at * runtime, in which case the value of OFnumeric_limits::traps * for floating-point types reflects the state of floating-point trapping * facility at the time of program startup. * @details *

C++11 standard definitions used:

* T | %traps * ----------------------- | --------------------------------- * non-specialized | OFFalse * OFBool | usually OFFalse * char | usually OFTrue * signed char | usually OFTrue * unsigned char | usually OFTrue * signed short | usually OFTrue * unsigned short | usually OFTrue * signed int | usually OFTrue * unsigned int | usually OFTrue * signed long | usually OFTrue * unsigned long | usually OFTrue * float | usually OFFalse * double | usually OFFalse */ static const OFBool traps; /** OFTrue for all floating-point types T that test * results of floating-point expressions for underflow before rounding. * @note Standard-compliant IEEE 754 floating-point implementations may * detect the floating-point underflow at three predefined moments: * 1. after computation of a result with absolute value smaller than * OFnumeric_limits::min(), such implementation detects * tinyness before rounding. * 2. after rounding of the result to OFnumeric_limits::digits * bits, if the result is tiny, such implementation detects tinyness * after rounding. * 3. if the conversion of the rounded tiny result to subnormal form * resulted in the loss of precision, such implementation detects * denorm loss. * @details *

C++11 standard definitions used:

* T | %tinyness_before * ----------------------- | ---------------------------------- * non-specialized | OFFalse * OFBool | OFFalse * char | OFFalse * signed char | OFFalse * unsigned char | OFFalse * signed short | OFFalse * unsigned short | OFFalse * signed int | OFFalse * unsigned int | OFFalse * signed long | OFFalse * unsigned long | OFFalse * float | platform / compiler specific * double | platform / compiler specific */ static const OFBool tinyness_before; /** The minimum finite value representable by the numeric type T. * For floating-point types with denormalization, min returns the * minimum positive normalized value. * @note This behavior may be unexpected, especially when compared to * the behavior of min for integral types. To find the value that has * no values less than it, use OFnumeric_limits::lowest(). * @note Min is only meaningful for bounded types and for unbounded * unsigned types, that is, types that represent an infinite set of * negative values have no meaningful minimum. * @details *

C++11 standard definitions used:

* T | %min() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | CHAR_MIN * signed char | SCHAR_MIN * unsigned char | 0 * signed short | SHRT_MIN * unsigned short | 0 * signed int | INT_MIN * unsigned int | 0 * signed long | LONG_MIN * unsigned long | 0 * float | FLT_MIN * double | DBL_MIN */ static T min(); /** The lowest finite value representable by the numeric type T, * that is, a finite value @f$x@f$ such that there is no other finite * value @f$y@f$ where @f$y < x@f$. * @note This is different from OFnumeric_limits::min() * for floating-point types. * @details *

C++11 standard definitions used:

* T | %lowest() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | CHAR_MIN * signed char | SCHAR_MIN * unsigned char | 0 * signed short | SHRT_MIN * unsigned short | 0 * signed int | INT_MIN * unsigned int | 0 * signed long | LONG_MIN * unsigned long | 0 * float | -FLT_MAX * double | -DBL_MAX */ static T lowest(); /** The maximum finite value representable by the numeric type T. * @note Meaningful for all bounded types. * @details *

C++11 standard definitions used:

* T | %max() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFTrue * char | CHAR_MAX * signed char | SCHAR_MAX * unsigned char | UCHAR_MAX * signed short | SHRT_MAX * unsigned short | USHRT_MAX * signed int | INT_MAN * unsigned int | UINT_MAX * signed long | LONG_MAX * unsigned long | ULONG_MAX * float | FLT_MAX * double | DBL_MAX */ static T max(); /** The machine epsilon, that is, the difference between @f$1.0@f$ * and the next value representable by the floating-point type T. * @note It is only meaningful if * OFnumeric_limits::is_integer == OFFalse. * @details *

C++11 standard definitions used:

* T | %epsilon() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | FLT_EPSILON * double | DBL_EPSILON */ static T epsilon(); /** The largest possible rounding error in ULPs (units in the last * place) as defined by ISO 10967, which can vary from @f$0.5@f$ * (rounding to the nearest digit) to @f$1.0@f$ (rounding to zero or * to infinity). * @note It is only meaningful if * OFnumeric_limits::is_integer == OFFalse. * @details *

C++11 standard definitions used:

* T | %round_error() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | 0.5f * double | 0.5 */ static T round_error(); /** The special value positive infinity, as represented * by the floating-point type T. * @note Only meaningful if * OFnumeric_limits::has_infinity == OFTrue. * @note In IEEE 754, the most common binary representation of * floating-point numbers, the positive infinity is the value * with all bits of the exponent set and all bits of the * fraction cleared. * @details *

C++11 standard definitions used:

* T | %infinity() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | HUGE_VALF * double | HUGE_VAL */ static T infinity(); /** The special value quiet not-a-number, as represented * by the floating-point type T. * @note Only meaningful if * OFnumeric_limits::has_quiet_NaN == OFTrue. * @note In IEEE 754, the most common binary representation of * floating-point numbers, any value with all bits of the exponent * set and at least one bit of the fraction set represents a NaN. * It is implementation-defined which values of the fraction * represent quiet or signaling NaNs, and whether the sign bit is * meaningful. * @details *

C++11 standard definitions used:

* T | %quiet_NaN() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | NAN or platform / compiler specific * double | platform / compiler specific */ static T quiet_NaN(); /** The special value signaling not-a-number, as represented * by the floating-point type T. * @note Only meaningful if * OFnumeric_limits::has_signaling_NaN == OFTrue. * @note In IEEE 754, the most common binary representation of * floating-point numbers, any value with all bits of the exponent * set and at least one bit of the fraction set represents a NaN. * It is implementation-defined which values of the fraction * represent quiet or signaling NaNs, and whether the sign bit is * meaningful. * @details *

C++11 standard definitions used:

* T | %signaling_NaN() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | platform / compiler specific * double | platform / compiler specific */ static T signaling_NaN(); /** The minimum positive subnormal value of the type T, if * OFnumeric_limits::has_denorm != OFdenorm_absent, * otherwise returns OFnumeric_limits::min(). * @note Only meaningful for floating-point types. * @details *

C++11 standard definitions used:

* T | %denorm_min() * ----------------------- | -------------- * non-specialized | T() * OFBool | OFFalse * char | 0 * signed char | 0 * unsigned char | 0 * signed short | 0 * unsigned short | 0 * signed int | 0 * unsigned int | 0 * signed long | 0 * unsigned long | 0 * float | usually @f$2^{-149}@f$ * double | usually @f$2^{-1074}@f$ */ static T denorm_min(); }; #else // DOXYGEN template struct OFnumeric_limits { static const OFBool is_specialized = OFFalse; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFFalse; static const OFBool is_exact = OFFalse; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFFalse; static const OFBool is_modulo = OFFalse; static const int digits = 0; static const int digits10 = 0; static const int max_digits10 = 0; static const int radix = 0; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = OFFalse; static const OFBool tinyness_before = OFFalse; static inline T (min)() { return T(); } static inline T lowest() { return T(); } static inline T (max)() { return T(); } static inline T epsilon() { return T(); } static inline T round_error() { return T(); } static inline T infinity() { return T(); } static inline T quiet_NaN() { return T(); } static inline T signaling_NaN() { return T(); } static inline T denorm_min() { return T(); } }; #ifdef HAVE_CXX_BOOL template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = OFFalse; static const int digits = 1; static const int digits10 = 0; static const int max_digits10 = 0; static const int radix = 0; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = OFFalse; static const OFBool tinyness_before = OFFalse; static inline bool (min)() { return OFFalse; } static inline bool lowest() { return OFFalse; } static inline bool (max)() { return OFTrue; } static inline bool epsilon() { return OFFalse; } static inline bool round_error() { return OFFalse; } static inline bool infinity() { return OFFalse; } static inline bool quiet_NaN() { return OFFalse; } static inline bool signaling_NaN() { return OFFalse; } static inline bool denorm_min() { return OFFalse; } }; #endif template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; #ifndef C_CHAR_UNSIGNED static const OFBool is_signed = OFTrue; #else static const OFBool is_signed = OFFalse; #endif static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_CHAR_MODULO; static const int digits = OFnumeric_limits::is_signed ? CHAR_BIT - 1 : CHAR_BIT; static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_CHAR_TRAPS; static const OFBool tinyness_before = OFFalse; static inline char (min)() { return OFstatic_cast( char, CHAR_MIN ); } static inline char lowest() { return OFstatic_cast( char, CHAR_MIN ); } static inline char (max)() { return OFstatic_cast( char, CHAR_MAX ); } static inline char epsilon() { return OFstatic_cast( char, 0 ); } static inline char round_error() { return OFstatic_cast( char, 0 ); } static inline char infinity() { return OFstatic_cast( char, 0 ); } static inline char quiet_NaN() { return OFstatic_cast( char, 0 ); } static inline char signaling_NaN() { return OFstatic_cast( char, 0 ); } static inline char denorm_min() { return OFstatic_cast( char, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_SIGNED_CHAR_MODULO; static const int digits = CHAR_BIT - 1; static const int digits10 = OFstatic_cast( int, ( CHAR_BIT - 1 ) * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_SIGNED_CHAR_TRAPS; static const OFBool tinyness_before = OFFalse; static inline signed char (min)() { return OFstatic_cast( signed char, SCHAR_MIN ); } static inline signed char lowest() { return OFstatic_cast( signed char, SCHAR_MIN ); } static inline signed char (max)() { return OFstatic_cast( signed char, SCHAR_MAX ); } static inline signed char epsilon() { return OFstatic_cast( signed char, 0 ); } static inline signed char round_error() { return OFstatic_cast( signed char, 0 ); } static inline signed char infinity() { return OFstatic_cast( signed char, 0 ); } static inline signed char quiet_NaN() { return OFstatic_cast( signed char, 0 ); } static inline signed char signaling_NaN() { return OFstatic_cast( signed char, 0 ); } static inline signed char denorm_min() { return OFstatic_cast( signed char, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_UNSIGNED_CHAR_MODULO; static const int digits = CHAR_BIT; static const int digits10 = OFstatic_cast( int, CHAR_BIT * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_UNSIGNED_CHAR_TRAPS; static const OFBool tinyness_before = OFFalse; static inline unsigned char (min)() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char lowest() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char (max)() { return OFstatic_cast( unsigned char, UCHAR_MAX ); } static inline unsigned char epsilon() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char round_error() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char infinity() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char quiet_NaN() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char signaling_NaN() { return OFstatic_cast( unsigned char, 0 ); } static inline unsigned char denorm_min() { return OFstatic_cast( unsigned char, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_SIGNED_SHORT_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( signed short ) - 1 ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_SIGNED_SHORT_TRAPS; static const OFBool tinyness_before = OFFalse; static inline signed short (min)() { return OFstatic_cast( signed short, SHRT_MIN ); } static inline signed short lowest() { return OFstatic_cast( signed short, SHRT_MIN ); } static inline signed short (max)() { return OFstatic_cast( signed short, SHRT_MAX ); } static inline signed short epsilon() { return OFstatic_cast( signed short, 0 ); } static inline signed short round_error() { return OFstatic_cast( signed short, 0 ); } static inline signed short infinity() { return OFstatic_cast( signed short, 0 ); } static inline signed short quiet_NaN() { return OFstatic_cast( signed short, 0 ); } static inline signed short signaling_NaN() { return OFstatic_cast( signed short, 0 ); } static inline signed short denorm_min() { return OFstatic_cast( signed short, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_UNSIGNED_SHORT_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( unsigned short ) ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_UNSIGNED_SHORT_TRAPS; static const OFBool tinyness_before = OFFalse; static inline unsigned short (min)() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short lowest() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short (max)() { return OFstatic_cast( unsigned short, USHRT_MAX ); } static inline unsigned short epsilon() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short round_error() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short infinity() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short quiet_NaN() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short signaling_NaN() { return OFstatic_cast( unsigned short, 0 ); } static inline unsigned short denorm_min() { return OFstatic_cast( unsigned short, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_SIGNED_INT_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( signed int ) - 1 ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_SIGNED_INT_TRAPS; static const OFBool tinyness_before = OFFalse; static inline signed int (min)() { return OFstatic_cast( signed int, INT_MIN ); } static inline signed int lowest() { return OFstatic_cast( signed int, INT_MIN ); } static inline signed int (max)() { return OFstatic_cast( signed int, INT_MAX ); } static inline signed int epsilon() { return OFstatic_cast( signed int, 0 ); } static inline signed int round_error() { return OFstatic_cast( signed int, 0 ); } static inline signed int infinity() { return OFstatic_cast( signed int, 0 ); } static inline signed int quiet_NaN() { return OFstatic_cast( signed int, 0 ); } static inline signed int signaling_NaN() { return OFstatic_cast( signed int, 0 ); } static inline signed int denorm_min() { return OFstatic_cast( signed int, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_UNSIGNED_INT_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( unsigned int ) ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_UNSIGNED_INT_TRAPS; static const OFBool tinyness_before = OFFalse; static inline unsigned int (min)() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int lowest() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int (max)() { return OFstatic_cast( unsigned int, UINT_MAX ); } static inline unsigned int epsilon() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int round_error() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int infinity() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int quiet_NaN() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int signaling_NaN() { return OFstatic_cast( unsigned int, 0 ); } static inline unsigned int denorm_min() { return OFstatic_cast( unsigned int, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_SIGNED_LONG_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( signed long ) - 1 ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_SIGNED_LONG_TRAPS; static const OFBool tinyness_before = OFFalse; static inline signed long (min)() { return OFstatic_cast( signed long, LONG_MIN ); } static inline signed long lowest() { return OFstatic_cast( signed long, LONG_MIN ); } static inline signed long (max)() { return OFstatic_cast( signed long, LONG_MAX ); } static inline signed long epsilon() { return OFstatic_cast( signed long, 0 ); } static inline signed long round_error() { return OFstatic_cast( signed long, 0 ); } static inline signed long infinity() { return OFstatic_cast( signed long, 0 ); } static inline signed long quiet_NaN() { return OFstatic_cast( signed long, 0 ); } static inline signed long signaling_NaN() { return OFstatic_cast( signed long, 0 ); } static inline signed long denorm_min() { return OFstatic_cast( signed long, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFFalse; static const OFBool is_integer = OFTrue; static const OFBool is_exact = OFTrue; static const OFBool has_infinity = OFFalse; static const OFBool has_quiet_NaN = OFFalse; static const OFBool has_signaling_NaN = OFFalse; static const OFfloat_denorm_style has_denorm = OFdenorm_absent; static const OFBool has_denorm_loss = OFFalse; static const OFfloat_round_style round_style = OFround_toward_zero; static const OFBool is_iec559 = OFFalse; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = DCMTK_UNSIGNED_LONG_MODULO; static const int digits = OFstatic_cast( int, CHAR_BIT * sizeof( unsigned long ) ); static const int digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 ); static const int max_digits10 = 0; static const int radix = 2; static const int min_exponent = 0; static const int min_exponent10 = 0; static const int max_exponent = 0; static const int max_exponent10 = 0; static const OFBool traps = DCMTK_UNSIGNED_LONG_TRAPS; static const OFBool tinyness_before = OFFalse; static inline unsigned long (min)() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long lowest() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long (max)() { return OFstatic_cast( unsigned long, ULONG_MAX ); } static inline unsigned long epsilon() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long round_error() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long infinity() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long quiet_NaN() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long signaling_NaN() { return OFstatic_cast( unsigned long, 0 ); } static inline unsigned long denorm_min() { return OFstatic_cast( unsigned long, 0 ); } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFFalse; static const OFBool is_exact = OFFalse; static const OFBool has_infinity = DCMTK_FLOAT_HAS_INFINITY; static const OFBool has_quiet_NaN = DCMTK_FLOAT_HAS_QUIET_NAN; static const OFBool has_signaling_NaN = DCMTK_FLOAT_HAS_SIGNALING_NAN; static const OFfloat_denorm_style has_denorm = DCMTK_FLOAT_HAS_DENORM; static const OFBool has_denorm_loss = DCMTK_FLOAT_HAS_DENORM_LOSS; static const OFfloat_round_style round_style = OFstatic_cast( OFfloat_round_style, DCMTK_ROUND_STYLE ); static const OFBool is_iec559 = DCMTK_FLOAT_IS_IEC559; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = OFFalse; static const int digits = OFstatic_cast( int, FLT_MANT_DIG ); static const int digits10 = OFstatic_cast( int, FLT_DIG ); static const int max_digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 + 2 ); static const int radix = FLT_RADIX; static const int min_exponent = FLT_MIN_EXP; static const int min_exponent10 = FLT_MIN_10_EXP; static const int max_exponent = FLT_MAX_EXP; static const int max_exponent10 = FLT_MAX_10_EXP; static const OFBool traps = DCMTK_FLOAT_TRAPS; static const OFBool tinyness_before = DCMTK_FLOAT_TINYNESS_BEFORE; static inline float (min)() { return OFstatic_cast( float, FLT_MIN ); } static inline float lowest() { return OFstatic_cast( float, -FLT_MAX ); } static inline float (max)() { return OFstatic_cast( float, FLT_MAX ); } static inline float epsilon() { return OFstatic_cast( float, FLT_EPSILON ); } static inline float round_error() { return OFstatic_cast( float, 0.5f ); } static inline float infinity() { return DCMTK_FLOAT_INFINITY; } static inline float quiet_NaN() { return DCMTK_FLOAT_QUIET_NAN; } static inline const float& signaling_NaN() { return DCMTK_FLOAT_SIGNALING_NAN; } static inline float denorm_min() { return DCMTK_FLOAT_DENORM_MIN; } }; template<> struct OFnumeric_limits { static const OFBool is_specialized = OFTrue; static const OFBool is_signed = OFTrue; static const OFBool is_integer = OFFalse; static const OFBool is_exact = OFFalse; static const OFBool has_infinity = DCMTK_DOUBLE_HAS_INFINITY; static const OFBool has_quiet_NaN = DCMTK_DOUBLE_HAS_QUIET_NAN; static const OFBool has_signaling_NaN = DCMTK_DOUBLE_HAS_SIGNALING_NAN; static const OFfloat_denorm_style has_denorm = DCMTK_DOUBLE_HAS_DENORM; static const OFBool has_denorm_loss = DCMTK_DOUBLE_HAS_DENORM_LOSS; static const OFfloat_round_style round_style = OFstatic_cast( OFfloat_round_style, DCMTK_ROUND_STYLE ); static const OFBool is_iec559 = DCMTK_DOUBLE_IS_IEC559; static const OFBool is_bounded = OFTrue; static const OFBool is_modulo = OFFalse; static const int digits = OFstatic_cast( int, DBL_MANT_DIG ); static const int digits10 = OFstatic_cast( int, DBL_DIG ); static const int max_digits10 = OFstatic_cast( int, OFnumeric_limits::digits * .30102999566398119521373889472449 + 2 ); static const int radix = FLT_RADIX; static const int min_exponent = DBL_MIN_EXP; static const int min_exponent10 = DBL_MIN_10_EXP; static const int max_exponent = DBL_MAX_EXP; static const int max_exponent10 = DBL_MAX_10_EXP; static const OFBool traps = DCMTK_DOUBLE_TRAPS; static const OFBool tinyness_before = DCMTK_DOUBLE_TINYNESS_BEFORE; static inline double (min)() { return OFstatic_cast( double, DBL_MIN ); } static inline double lowest() { return OFstatic_cast( double, -DBL_MAX ); } static inline double (max)() { return OFstatic_cast( double, DBL_MAX ); } static inline double epsilon() { return OFstatic_cast( double, DBL_EPSILON ); } static inline double round_error() { return OFstatic_cast( double, 0.5 ); } static inline double infinity() { return DCMTK_DOUBLE_INFINITY; } static inline double quiet_NaN() { return DCMTK_DOUBLE_QUIET_NAN; } static inline double signaling_NaN() { return DCMTK_DOUBLE_SIGNALING_NAN; } static inline double denorm_min() { return DCMTK_DOUBLE_DENORM_MIN; } }; #endif // DOXYGEN #endif // C++11 #endif // OFLIMITS_H