123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173 |
- /*
- * 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 "include/core/SkTypes.h"
- #include <limits.h>
- #include <float.h>
- template <size_t size>
- class SkTypeWithSize {
- public:
- // Prevents using SkTypeWithSize<N> 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 <typename RawType>
- struct SkNumericLimits {
- static const int digits = 0;
- };
- template <>
- struct SkNumericLimits<double> {
- static const int digits = DBL_MANT_DIG;
- };
- template <>
- struct SkNumericLimits<float> {
- 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 <typename RawType, unsigned int ULPs>
- class SkFloatingPoint {
- public:
- /** Bits is a unsigned integer the same size as the floating point number. */
- typedef typename SkTypeWithSize<sizeof(RawType) * CHAR_BIT>::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<RawType>::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<Bits>(1) << (kBitCount - 1);
- /** The mask for the fraction bits. */
- static const Bits kFractionBitMask =
- ~static_cast<Bits>(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
|