blob: 101aac7474d2aa579e78e1ef3440af75c7c11f84 [file] [log] [blame]
 /* * Copyright 2012 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef SkFloatUtils_DEFINED #define SkFloatUtils_DEFINED #include "SkTypes.h" #include #include template class SkTypeWithSize { public: // Prevents using SkTypeWithSize with non-specialized N. typedef void UInt; }; template <> class SkTypeWithSize<32> { public: typedef uint32_t UInt; }; template <> class SkTypeWithSize<64> { public: typedef uint64_t UInt; }; template struct SkNumericLimits { static const int digits = 0; }; template <> struct SkNumericLimits { static const int digits = DBL_MANT_DIG; }; template <> struct SkNumericLimits { static const int digits = FLT_MANT_DIG; }; //See //http://stackoverflow.com/questions/17333/most-effective-way-for-float-and-double-comparison/3423299#3423299 //http://code.google.com/p/googletest/source/browse/trunk/include/gtest/internal/gtest-internal.h //http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm template class SkFloatingPoint { public: /** Bits is a unsigned integer the same size as the floating point number. */ typedef typename SkTypeWithSize::UInt Bits; /** # of bits in a number. */ static const size_t kBitCount = CHAR_BIT * sizeof(RawType); /** # of fraction bits in a number. */ static const size_t kFractionBitCount = SkNumericLimits::digits - 1; /** # of exponent bits in a number. */ static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; /** The mask for the sign bit. */ static const Bits kSignBitMask = static_cast(1) << (kBitCount - 1); /** The mask for the fraction bits. */ static const Bits kFractionBitMask = ~static_cast(0) >> (kExponentBitCount + 1); /** The mask for the exponent bits. */ static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); /** How many ULP's (Units in the Last Place) to tolerate when comparing. */ static const size_t kMaxUlps = ULPs; /** * Constructs a FloatingPoint from a raw floating-point number. * * On an Intel CPU, passing a non-normalized NAN (Not a Number) * around may change its bits, although the new value is guaranteed * to be also a NAN. Therefore, don't expect this constructor to * preserve the bits in x when x is a NAN. */ explicit SkFloatingPoint(const RawType& x) { fU.value = x; } /** Returns the exponent bits of this number. */ Bits exponent_bits() const { return kExponentBitMask & fU.bits; } /** Returns the fraction bits of this number. */ Bits fraction_bits() const { return kFractionBitMask & fU.bits; } /** Returns true iff this is NAN (not a number). */ bool is_nan() const { // It's a NAN if both of the folloowing are true: // * the exponent bits are all ones // * the fraction bits are not all zero. return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); } /** * Returns true iff this number is at most kMaxUlps ULP's away from ths. * In particular, this function: * - returns false if either number is (or both are) NAN. * - treats really large numbers as almost equal to infinity. * - thinks +0.0 and -0.0 are 0 DLP's apart. */ bool AlmostEquals(const SkFloatingPoint& rhs) const { // Any comparison operation involving a NAN must return false. if (is_nan() || rhs.is_nan()) return false; const Bits dist = DistanceBetweenSignAndMagnitudeNumbers(fU.bits, rhs.fU.bits); //SkDEBUGF(("(%f, %f, %d) ", u_.value_, rhs.u_.value_, dist)); return dist <= kMaxUlps; } private: /** The data type used to store the actual floating-point number. */ union FloatingPointUnion { /** The raw floating-point number. */ RawType value; /** The bits that represent the number. */ Bits bits; }; /** * Converts an integer from the sign-and-magnitude representation to * the biased representation. More precisely, let N be 2 to the * power of (kBitCount - 1), an integer x is represented by the * unsigned number x + N. * * For instance, * * -N + 1 (the most negative number representable using * sign-and-magnitude) is represented by 1; * 0 is represented by N; and * N - 1 (the biggest number representable using * sign-and-magnitude) is represented by 2N - 1. * * Read http://en.wikipedia.org/wiki/Signed_number_representations * for more details on signed number representations. */ static Bits SignAndMagnitudeToBiased(const Bits &sam) { if (kSignBitMask & sam) { // sam represents a negative number. return ~sam + 1; } else { // sam represents a positive number. return kSignBitMask | sam; } } /** * Given two numbers in the sign-and-magnitude representation, * returns the distance between them as an unsigned number. */ static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, const Bits &sam2) { const Bits biased1 = SignAndMagnitudeToBiased(sam1); const Bits biased2 = SignAndMagnitudeToBiased(sam2); return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); } FloatingPointUnion fU; }; #endif