| // Copyright 2005 Google Inc. |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // --- |
| // |
| // |
| // Useful integer and floating point limits and type traits. |
| // |
| // This partially replaces/duplictes numeric_limits<> from <limits>. |
| // We get a Google-style class that we have a greater control over |
| // and thus can add new features to it or fix whatever happens to be broken in |
| // numeric_limits for the compilers we use. |
| // |
| |
| #ifndef UTIL_MATH_MATHLIMITS_H__ |
| #define UTIL_MATH_MATHLIMITS_H__ |
| |
| #include <cfloat> |
| #include <cmath> |
| |
| // ========================================================================= // |
| |
| // Useful integer and floating point limits and type traits. |
| // This is just for the documentation; |
| // real members are defined in our specializations below. |
| template<typename T> struct MathLimits { |
| // Type name. |
| typedef T Type; |
| // Unsigned version of the Type with the same byte size. |
| // Same as Type for floating point and unsigned types. |
| typedef T UnsignedType; |
| // If the type supports negative values. |
| static const bool kIsSigned; |
| // If the type supports only integer values. |
| static const bool kIsInteger; |
| // Magnitude-wise smallest representable positive value. |
| static const Type kPosMin; |
| // Magnitude-wise largest representable positive value. |
| static const Type kPosMax; |
| // Smallest representable value. |
| static const Type kMin; |
| // Largest representable value. |
| static const Type kMax; |
| // Magnitude-wise smallest representable negative value. |
| // Present only if kIsSigned. |
| static const Type kNegMin; |
| // Magnitude-wise largest representable negative value. |
| // Present only if kIsSigned. |
| static const Type kNegMax; |
| // Smallest integer x such that 10^x is representable. |
| static const int kMin10Exp; |
| // Largest integer x such that 10^x is representable. |
| static const int kMax10Exp; |
| // Smallest positive value such that Type(1) + kEpsilon != Type(1) |
| static const Type kEpsilon; |
| // Typical rounding error that is enough to cover |
| // a few simple floating-point operations. |
| // Slightly larger than kEpsilon to account for a few rounding errors. |
| // Is zero if kIsInteger. |
| static const Type kStdError; |
| // Number of decimal digits of mantissa precision. |
| // Present only if !kIsInteger. |
| static const int kPrecisionDigits; |
| // Not a number, i.e. result of 0/0. |
| // Present only if !kIsInteger. |
| static const Type kNaN; |
| // Positive infinity, i.e. result of 1/0. |
| // Present only if !kIsInteger. |
| static const Type kPosInf; |
| // Negative infinity, i.e. result of -1/0. |
| // Present only if !kIsInteger. |
| static const Type kNegInf; |
| |
| // NOTE: Special floating point values behave |
| // in a special (but mathematically-logical) way |
| // in terms of (in)equalty comparison and mathematical operations |
| // -- see out unittest for examples. |
| |
| // Special floating point value testers. |
| // Present in integer types for convenience. |
| static bool IsFinite(const Type x); |
| static bool IsNaN(const Type x); |
| static bool IsInf(const Type x); |
| static bool IsPosInf(const Type x); |
| static bool IsNegInf(const Type x); |
| }; |
| |
| // ========================================================================= // |
| |
| // All #define-s below are simply to refactor the declarations of |
| // MathLimits template specializations. |
| // They are all #undef-ined below. |
| |
| // The hoop-jumping in *_INT_(MAX|MIN) below is so that the compiler does not |
| // get an overflow while computing the constants. |
| |
| #define SIGNED_INT_MAX(Type) \ |
| (((Type(1) << (sizeof(Type)*8 - 2)) - 1) + (Type(1) << (sizeof(Type)*8 - 2))) |
| |
| #define SIGNED_INT_MIN(Type) \ |
| (-(Type(1) << (sizeof(Type)*8 - 2)) - (Type(1) << (sizeof(Type)*8 - 2))) |
| |
| #define UNSIGNED_INT_MAX(Type) \ |
| (((Type(1) << (sizeof(Type)*8 - 1)) - 1) + (Type(1) << (sizeof(Type)*8 - 1))) |
| |
| // Compile-time selected log10-related constants for integer types. |
| #define SIGNED_MAX_10_EXP(Type) \ |
| (sizeof(Type) == 1 ? 2 : ( \ |
| sizeof(Type) == 2 ? 4 : ( \ |
| sizeof(Type) == 4 ? 9 : ( \ |
| sizeof(Type) == 8 ? 18 : -1)))) |
| |
| #define UNSIGNED_MAX_10_EXP(Type) \ |
| (sizeof(Type) == 1 ? 2 : ( \ |
| sizeof(Type) == 2 ? 4 : ( \ |
| sizeof(Type) == 4 ? 9 : ( \ |
| sizeof(Type) == 8 ? 19 : -1)))) |
| |
| #define DECL_INT_LIMIT_FUNCS \ |
| static bool IsFinite(const Type x) { return true; } \ |
| static bool IsNaN(const Type x) { return false; } \ |
| static bool IsInf(const Type x) { return false; } \ |
| static bool IsPosInf(const Type x) { return false; } \ |
| static bool IsNegInf(const Type x) { return false; } |
| |
| #define DECL_SIGNED_INT_LIMITS(IntType, UnsignedIntType) \ |
| template<> \ |
| struct MathLimits<IntType> { \ |
| typedef IntType Type; \ |
| typedef UnsignedIntType UnsignedType; \ |
| static const bool kIsSigned = true; \ |
| static const bool kIsInteger = true; \ |
| static const Type kPosMin = 1; \ |
| static const Type kPosMax = SIGNED_INT_MAX(Type); \ |
| static const Type kMin = SIGNED_INT_MIN(Type); \ |
| static const Type kMax = kPosMax; \ |
| static const Type kNegMin = -1; \ |
| static const Type kNegMax = kMin; \ |
| static const int kMin10Exp = 0; \ |
| static const int kMax10Exp = SIGNED_MAX_10_EXP(Type); \ |
| static const Type kEpsilon = 1; \ |
| static const Type kStdError = 0; \ |
| DECL_INT_LIMIT_FUNCS \ |
| }; |
| |
| #define DECL_UNSIGNED_INT_LIMITS(IntType) \ |
| template<> \ |
| struct MathLimits<IntType> { \ |
| typedef IntType Type; \ |
| typedef IntType UnsignedType; \ |
| static const bool kIsSigned = false; \ |
| static const bool kIsInteger = true; \ |
| static const Type kPosMin = 1; \ |
| static const Type kPosMax = UNSIGNED_INT_MAX(Type); \ |
| static const Type kMin = 0; \ |
| static const Type kMax = kPosMax; \ |
| static const int kMin10Exp = 0; \ |
| static const int kMax10Exp = UNSIGNED_MAX_10_EXP(Type); \ |
| static const Type kEpsilon = 1; \ |
| static const Type kStdError = 0; \ |
| DECL_INT_LIMIT_FUNCS \ |
| }; |
| |
| DECL_SIGNED_INT_LIMITS(signed char, unsigned char) |
| DECL_SIGNED_INT_LIMITS(signed short int, unsigned short int) |
| DECL_SIGNED_INT_LIMITS(signed int, unsigned int) |
| DECL_SIGNED_INT_LIMITS(signed long int, unsigned long int) |
| DECL_SIGNED_INT_LIMITS(signed long long int, unsigned long long int) |
| DECL_SIGNED_INT_LIMITS(signed __int128, unsigned __int128) |
| DECL_UNSIGNED_INT_LIMITS(unsigned char) |
| DECL_UNSIGNED_INT_LIMITS(unsigned short int) |
| DECL_UNSIGNED_INT_LIMITS(unsigned int) |
| DECL_UNSIGNED_INT_LIMITS(unsigned long int) |
| DECL_UNSIGNED_INT_LIMITS(unsigned long long int) |
| DECL_UNSIGNED_INT_LIMITS(unsigned __int128) |
| |
| #undef DECL_SIGNED_INT_LIMITS |
| #undef DECL_UNSIGNED_INT_LIMITS |
| #undef SIGNED_INT_MAX |
| #undef SIGNED_INT_MIN |
| #undef UNSIGNED_INT_MAX |
| #undef SIGNED_MAX_10_EXP |
| #undef UNSIGNED_MAX_10_EXP |
| #undef DECL_INT_LIMIT_FUNCS |
| |
| // ========================================================================= // |
| #ifdef WIN32 // Lacks built-in isnan() and isinf() |
| #define DECL_FP_LIMIT_FUNCS \ |
| static bool IsFinite(const Type x) { return _finite(x); } \ |
| static bool IsNaN(const Type x) { return _isnan(x); } \ |
| static bool IsInf(const Type x) { return (_fpclass(x) & (_FPCLASS_NINF | _FPCLASS_PINF)) != 0; } \ |
| static bool IsPosInf(const Type x) { return _fpclass(x) == _FPCLASS_PINF; } \ |
| static bool IsNegInf(const Type x) { return _fpclass(x) == _FPCLASS_NINF; } |
| #else |
| #define DECL_FP_LIMIT_FUNCS \ |
| static bool IsFinite(const Type x) { return !std::isinf(x) && !std::isnan(x); } \ |
| static bool IsNaN(const Type x) { return std::isnan(x); } \ |
| static bool IsInf(const Type x) { return std::isinf(x); } \ |
| static bool IsPosInf(const Type x) { return std::isinf(x) && x > 0; } \ |
| static bool IsNegInf(const Type x) { return std::isinf(x) && x < 0; } |
| #endif |
| |
| // We can't put floating-point constant values in the header here because |
| // such constants are not considered to be primitive-type constants by gcc. |
| // CAVEAT: Hence, they are going to be initialized only during |
| // the global objects construction time. |
| #define DECL_FP_LIMITS(FP_Type, PREFIX) \ |
| template<> \ |
| struct MathLimits<FP_Type> { \ |
| typedef FP_Type Type; \ |
| typedef FP_Type UnsignedType; \ |
| static const bool kIsSigned = true; \ |
| static const bool kIsInteger = false; \ |
| static const Type kPosMin; \ |
| static const Type kPosMax; \ |
| static const Type kMin; \ |
| static const Type kMax; \ |
| static const Type kNegMin; \ |
| static const Type kNegMax; \ |
| static const int kMin10Exp = PREFIX##_MIN_10_EXP; \ |
| static const int kMax10Exp = PREFIX##_MAX_10_EXP; \ |
| static const Type kEpsilon; \ |
| static const Type kStdError; \ |
| static const int kPrecisionDigits = PREFIX##_DIG; \ |
| static const Type kNaN; \ |
| static const Type kPosInf; \ |
| static const Type kNegInf; \ |
| DECL_FP_LIMIT_FUNCS \ |
| }; |
| |
| DECL_FP_LIMITS(float, FLT) |
| DECL_FP_LIMITS(double, DBL) |
| DECL_FP_LIMITS(long double, LDBL) |
| |
| #undef DECL_FP_LIMITS |
| #undef DECL_FP_LIMIT_FUNCS |
| |
| // ========================================================================= // |
| |
| #endif // UTIL_MATH_MATHLIMITS_H__ |