|
| 1 | +#pragma once |
| 2 | + |
| 3 | +#include <cmath> |
| 4 | +// Copyright 2005, Google Inc. |
| 5 | +// All rights reserved. |
| 6 | +// |
| 7 | +// Redistribution and use in source and binary forms, with or without |
| 8 | +// modification, are permitted provided that the following conditions are |
| 9 | +// met: |
| 10 | +// |
| 11 | +// * Redistributions of source code must retain the above copyright |
| 12 | +// notice, this list of conditions and the following disclaimer. |
| 13 | +// * Redistributions in binary form must reproduce the above |
| 14 | +// copyright notice, this list of conditions and the following disclaimer |
| 15 | +// in the documentation and/or other materials provided with the |
| 16 | +// distribution. |
| 17 | +// * Neither the name of Google Inc. nor the names of its |
| 18 | +// contributors may be used to endorse or promote products derived from |
| 19 | +// this software without specific prior written permission. |
| 20 | +// |
| 21 | +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 22 | +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 23 | +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 24 | +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 25 | +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 26 | +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 27 | +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 28 | +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 29 | +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 30 | +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 31 | +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 32 | +// |
| 33 | +// The Google C++ Testing and Mocking Framework (Google Test) |
| 34 | +// |
| 35 | +// This header file declares functions and macros used internally by |
| 36 | +// Google Test. They are subject to change without notice. |
| 37 | + |
| 38 | +using Bits = uint32_t; |
| 39 | + |
| 40 | +// this avoids the "dereferencing type-punned pointer |
| 41 | +// will break strict-aliasing rules" error |
| 42 | +union Float { |
| 43 | + float float_; |
| 44 | + Bits bits_; |
| 45 | +}; |
| 46 | + |
| 47 | +// # of bits in a number. |
| 48 | +static const size_t kBitCount = 8*sizeof(Bits); |
| 49 | +// The mask for the sign bit. |
| 50 | +static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); |
| 51 | + |
| 52 | +// GOOGLETEST_CM0001 DO NOT DELETE |
| 53 | + |
| 54 | +// Converts an integer from the sign-and-magnitude representation to |
| 55 | +// the biased representation. More precisely, let N be 2 to the |
| 56 | +// power of (kBitCount - 1), an integer x is represented by the |
| 57 | +// unsigned number x + N. |
| 58 | +// |
| 59 | +// For instance, |
| 60 | +// |
| 61 | +// -N + 1 (the most negative number representable using |
| 62 | +// sign-and-magnitude) is represented by 1; |
| 63 | +// 0 is represented by N; and |
| 64 | +// N - 1 (the biggest number representable using |
| 65 | +// sign-and-magnitude) is represented by 2N - 1. |
| 66 | +// |
| 67 | +// Read http://en.wikipedia.org/wiki/Signed_number_representations |
| 68 | +// for more details on signed number representations. |
| 69 | +static Bits SignAndMagnitudeToBiased(const Bits &sam) { |
| 70 | + if (kSignBitMask & sam) { |
| 71 | + // sam represents a negative number. |
| 72 | + return ~sam + 1; |
| 73 | + } else { |
| 74 | + // sam represents a positive number. |
| 75 | + return kSignBitMask | sam; |
| 76 | + } |
| 77 | +} |
| 78 | + |
| 79 | +// Given two numbers in the sign-and-magnitude representation, |
| 80 | +// returns the distance between them as an unsigned number. |
| 81 | +static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, |
| 82 | + const Bits &sam2) { |
| 83 | + const Bits biased1 = SignAndMagnitudeToBiased(sam1); |
| 84 | + const Bits biased2 = SignAndMagnitudeToBiased(sam2); |
| 85 | + return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); |
| 86 | +} |
| 87 | + |
| 88 | +// How many ULP's (Units in the Last Place) we want to tolerate when |
| 89 | +// comparing two numbers. The larger the value, the more error we |
| 90 | +// allow. A 0 value means that two numbers must be exactly the same |
| 91 | +// to be considered equal. |
| 92 | +// |
| 93 | +// The maximum error of a single floating-point operation is 0.5 |
| 94 | +// units in the last place. On Intel CPU's, all floating-point |
| 95 | +// calculations are done with 80-bit precision, while double has 64 |
| 96 | +// bits. Therefore, 4 should be enough for ordinary use. |
| 97 | +// |
| 98 | +// See the following article for more details on ULP: |
| 99 | +// http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ |
| 100 | +static const size_t kMaxUlps = 4; |
| 101 | + |
| 102 | +// Returns true if and only if this number is at most kMaxUlps ULP's away |
| 103 | +// from rhs. In particular, this function: |
| 104 | +// |
| 105 | +// - returns false if either number is (or both are) NAN. |
| 106 | +// - treats really large numbers as almost equal to infinity. |
| 107 | +// - thinks +0.0 and -0.0 are 0 DLP's apart. |
| 108 | +inline bool AlmostEquals(float lhs, float rhs) { |
| 109 | + // The IEEE standard says that any comparison operation involving |
| 110 | + // a NAN must return false. |
| 111 | + if (std::isnan(lhs) || std::isnan(rhs)) |
| 112 | + return false; |
| 113 | + |
| 114 | + Float l = {lhs}; |
| 115 | + Float r = {rhs}; |
| 116 | + |
| 117 | + return DistanceBetweenSignAndMagnitudeNumbers(l.bits_, r.bits_) <= kMaxUlps; |
| 118 | +} |
0 commit comments