diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/skia/skia/src/utils/SkFloatUtils.h | 173 |
1 files changed, 173 insertions, 0 deletions
diff --git a/gfx/skia/skia/src/utils/SkFloatUtils.h b/gfx/skia/skia/src/utils/SkFloatUtils.h new file mode 100644 index 0000000000..f89a77254e --- /dev/null +++ b/gfx/skia/skia/src/utils/SkFloatUtils.h @@ -0,0 +1,173 @@ +/* + * 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 |