/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "mozilla/FloatingPoint.h" #include <math.h> using mozilla::ExponentComponent; using mozilla::FloatingPoint; using mozilla::FuzzyEqualsAdditive; using mozilla::FuzzyEqualsMultiplicative; using mozilla::IsFinite; using mozilla::IsInfinite; using mozilla::IsNaN; using mozilla::IsNegative; using mozilla::IsNegativeZero; using mozilla::IsPositiveZero; using mozilla::NegativeInfinity; using mozilla::NumberEqualsInt32; using mozilla::NumberIsInt32; using mozilla::NumbersAreIdentical; using mozilla::PositiveInfinity; using mozilla::SpecificNaN; using mozilla::UnspecifiedNaN; #define A(a) MOZ_RELEASE_ASSERT(a) template<typename T> static void ShouldBeIdentical(T aD1, T aD2) { A(NumbersAreIdentical(aD1, aD2)); A(NumbersAreIdentical(aD2, aD1)); } template<typename T> static void ShouldNotBeIdentical(T aD1, T aD2) { A(!NumbersAreIdentical(aD1, aD2)); A(!NumbersAreIdentical(aD2, aD1)); } static void TestDoublesAreIdentical() { ShouldBeIdentical(+0.0, +0.0); ShouldBeIdentical(-0.0, -0.0); ShouldNotBeIdentical(+0.0, -0.0); ShouldBeIdentical(1.0, 1.0); ShouldNotBeIdentical(-1.0, 1.0); ShouldBeIdentical(4294967295.0, 4294967295.0); ShouldNotBeIdentical(-4294967295.0, 4294967295.0); ShouldBeIdentical(4294967296.0, 4294967296.0); ShouldBeIdentical(4294967297.0, 4294967297.0); ShouldBeIdentical(1e300, 1e300); ShouldBeIdentical(PositiveInfinity<double>(), PositiveInfinity<double>()); ShouldBeIdentical(NegativeInfinity<double>(), NegativeInfinity<double>()); ShouldNotBeIdentical(PositiveInfinity<double>(), NegativeInfinity<double>()); ShouldNotBeIdentical(-0.0, NegativeInfinity<double>()); ShouldNotBeIdentical(+0.0, NegativeInfinity<double>()); ShouldNotBeIdentical(1e300, NegativeInfinity<double>()); ShouldNotBeIdentical(3.141592654, NegativeInfinity<double>()); ShouldBeIdentical(UnspecifiedNaN<double>(), UnspecifiedNaN<double>()); ShouldBeIdentical(-UnspecifiedNaN<double>(), UnspecifiedNaN<double>()); ShouldBeIdentical(UnspecifiedNaN<double>(), -UnspecifiedNaN<double>()); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 42)); ShouldBeIdentical(SpecificNaN<double>(1, 17), SpecificNaN<double>(1, 42)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(1, 42)); ShouldBeIdentical(SpecificNaN<double>(1, 17), SpecificNaN<double>(0, 42)); const uint64_t Mask = 0xfffffffffffffULL; for (unsigned i = 0; i < 52; i++) { for (unsigned j = 0; j < 52; j++) { for (unsigned sign = 0; i < 2; i++) { ShouldBeIdentical(SpecificNaN<double>(0, 1ULL << i), SpecificNaN<double>(sign, 1ULL << j)); ShouldBeIdentical(SpecificNaN<double>(1, 1ULL << i), SpecificNaN<double>(sign, 1ULL << j)); ShouldBeIdentical(SpecificNaN<double>(0, Mask & ~(1ULL << i)), SpecificNaN<double>(sign, Mask & ~(1ULL << j))); ShouldBeIdentical(SpecificNaN<double>(1, Mask & ~(1ULL << i)), SpecificNaN<double>(sign, Mask & ~(1ULL << j))); } } } ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x8000000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x4000000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x2000000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x1000000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0800000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0400000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0200000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0100000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0080000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0040000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0020000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(0, 17), SpecificNaN<double>(0, 0x0010000000000ULL)); ShouldBeIdentical(SpecificNaN<double>(1, 17), SpecificNaN<double>(0, 0xff0ffffffffffULL)); ShouldBeIdentical(SpecificNaN<double>(1, 17), SpecificNaN<double>(0, 0xfffffffffff0fULL)); ShouldNotBeIdentical(UnspecifiedNaN<double>(), +0.0); ShouldNotBeIdentical(UnspecifiedNaN<double>(), -0.0); ShouldNotBeIdentical(UnspecifiedNaN<double>(), 1.0); ShouldNotBeIdentical(UnspecifiedNaN<double>(), -1.0); ShouldNotBeIdentical(UnspecifiedNaN<double>(), PositiveInfinity<double>()); ShouldNotBeIdentical(UnspecifiedNaN<double>(), NegativeInfinity<double>()); } static void TestFloatsAreIdentical() { ShouldBeIdentical(+0.0f, +0.0f); ShouldBeIdentical(-0.0f, -0.0f); ShouldNotBeIdentical(+0.0f, -0.0f); ShouldBeIdentical(1.0f, 1.0f); ShouldNotBeIdentical(-1.0f, 1.0f); ShouldBeIdentical(8388607.0f, 8388607.0f); ShouldNotBeIdentical(-8388607.0f, 8388607.0f); ShouldBeIdentical(8388608.0f, 8388608.0f); ShouldBeIdentical(8388609.0f, 8388609.0f); ShouldBeIdentical(1e36f, 1e36f); ShouldBeIdentical(PositiveInfinity<float>(), PositiveInfinity<float>()); ShouldBeIdentical(NegativeInfinity<float>(), NegativeInfinity<float>()); ShouldNotBeIdentical(PositiveInfinity<float>(), NegativeInfinity<float>()); ShouldNotBeIdentical(-0.0f, NegativeInfinity<float>()); ShouldNotBeIdentical(+0.0f, NegativeInfinity<float>()); ShouldNotBeIdentical(1e36f, NegativeInfinity<float>()); ShouldNotBeIdentical(3.141592654f, NegativeInfinity<float>()); ShouldBeIdentical(UnspecifiedNaN<float>(), UnspecifiedNaN<float>()); ShouldBeIdentical(-UnspecifiedNaN<float>(), UnspecifiedNaN<float>()); ShouldBeIdentical(UnspecifiedNaN<float>(), -UnspecifiedNaN<float>()); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 42)); ShouldBeIdentical(SpecificNaN<float>(1, 17), SpecificNaN<float>(1, 42)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(1, 42)); ShouldBeIdentical(SpecificNaN<float>(1, 17), SpecificNaN<float>(0, 42)); const uint32_t Mask = 0x7fffffUL; for (unsigned i = 0; i < 23; i++) { for (unsigned j = 0; j < 23; j++) { for (unsigned sign = 0; i < 2; i++) { ShouldBeIdentical(SpecificNaN<float>(0, 1UL << i), SpecificNaN<float>(sign, 1UL << j)); ShouldBeIdentical(SpecificNaN<float>(1, 1UL << i), SpecificNaN<float>(sign, 1UL << j)); ShouldBeIdentical(SpecificNaN<float>(0, Mask & ~(1UL << i)), SpecificNaN<float>(sign, Mask & ~(1UL << j))); ShouldBeIdentical(SpecificNaN<float>(1, Mask & ~(1UL << i)), SpecificNaN<float>(sign, Mask & ~(1UL << j))); } } } ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x700000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x400000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x200000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x100000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x080000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x040000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x020000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x010000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x008000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x004000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x002000)); ShouldBeIdentical(SpecificNaN<float>(0, 17), SpecificNaN<float>(0, 0x001000)); ShouldBeIdentical(SpecificNaN<float>(1, 17), SpecificNaN<float>(0, 0x7f0fff)); ShouldBeIdentical(SpecificNaN<float>(1, 17), SpecificNaN<float>(0, 0x7fff0f)); ShouldNotBeIdentical(UnspecifiedNaN<float>(), +0.0f); ShouldNotBeIdentical(UnspecifiedNaN<float>(), -0.0f); ShouldNotBeIdentical(UnspecifiedNaN<float>(), 1.0f); ShouldNotBeIdentical(UnspecifiedNaN<float>(), -1.0f); ShouldNotBeIdentical(UnspecifiedNaN<float>(), PositiveInfinity<float>()); ShouldNotBeIdentical(UnspecifiedNaN<float>(), NegativeInfinity<float>()); } static void TestAreIdentical() { TestDoublesAreIdentical(); TestFloatsAreIdentical(); } static void TestDoubleExponentComponent() { A(ExponentComponent(0.0) == -int_fast16_t(FloatingPoint<double>::kExponentBias)); A(ExponentComponent(-0.0) == -int_fast16_t(FloatingPoint<double>::kExponentBias)); A(ExponentComponent(0.125) == -3); A(ExponentComponent(0.5) == -1); A(ExponentComponent(1.0) == 0); A(ExponentComponent(1.5) == 0); A(ExponentComponent(2.0) == 1); A(ExponentComponent(7.0) == 2); A(ExponentComponent(PositiveInfinity<double>()) == FloatingPoint<double>::kExponentBias + 1); A(ExponentComponent(NegativeInfinity<double>()) == FloatingPoint<double>::kExponentBias + 1); A(ExponentComponent(UnspecifiedNaN<double>()) == FloatingPoint<double>::kExponentBias + 1); } static void TestFloatExponentComponent() { A(ExponentComponent(0.0f) == -int_fast16_t(FloatingPoint<float>::kExponentBias)); A(ExponentComponent(-0.0f) == -int_fast16_t(FloatingPoint<float>::kExponentBias)); A(ExponentComponent(0.125f) == -3); A(ExponentComponent(0.5f) == -1); A(ExponentComponent(1.0f) == 0); A(ExponentComponent(1.5f) == 0); A(ExponentComponent(2.0f) == 1); A(ExponentComponent(7.0f) == 2); A(ExponentComponent(PositiveInfinity<float>()) == FloatingPoint<float>::kExponentBias + 1); A(ExponentComponent(NegativeInfinity<float>()) == FloatingPoint<float>::kExponentBias + 1); A(ExponentComponent(UnspecifiedNaN<float>()) == FloatingPoint<float>::kExponentBias + 1); } static void TestExponentComponent() { TestDoubleExponentComponent(); TestFloatExponentComponent(); } static void TestDoublesPredicates() { A(IsNaN(UnspecifiedNaN<double>())); A(IsNaN(SpecificNaN<double>(1, 17)));; A(IsNaN(SpecificNaN<double>(0, 0xfffffffffff0fULL))); A(!IsNaN(0.0)); A(!IsNaN(-0.0)); A(!IsNaN(1.0)); A(!IsNaN(PositiveInfinity<double>())); A(!IsNaN(NegativeInfinity<double>())); A(IsInfinite(PositiveInfinity<double>())); A(IsInfinite(NegativeInfinity<double>())); A(!IsInfinite(UnspecifiedNaN<double>())); A(!IsInfinite(0.0)); A(!IsInfinite(-0.0)); A(!IsInfinite(1.0)); A(!IsFinite(PositiveInfinity<double>())); A(!IsFinite(NegativeInfinity<double>())); A(!IsFinite(UnspecifiedNaN<double>())); A(IsFinite(0.0)); A(IsFinite(-0.0)); A(IsFinite(1.0)); A(!IsNegative(PositiveInfinity<double>())); A(IsNegative(NegativeInfinity<double>())); A(IsNegative(-0.0)); A(!IsNegative(0.0)); A(IsNegative(-1.0)); A(!IsNegative(1.0)); A(!IsNegativeZero(PositiveInfinity<double>())); A(!IsNegativeZero(NegativeInfinity<double>())); A(!IsNegativeZero(SpecificNaN<double>(1, 17)));; A(!IsNegativeZero(SpecificNaN<double>(1, 0xfffffffffff0fULL))); A(!IsNegativeZero(SpecificNaN<double>(0, 17)));; A(!IsNegativeZero(SpecificNaN<double>(0, 0xfffffffffff0fULL))); A(!IsNegativeZero(UnspecifiedNaN<double>())); A(IsNegativeZero(-0.0)); A(!IsNegativeZero(0.0)); A(!IsNegativeZero(-1.0)); A(!IsNegativeZero(1.0)); int32_t i; A(NumberIsInt32(0.0, &i)); A(i == 0); A(!NumberIsInt32(-0.0, &i)); A(NumberEqualsInt32(0.0, &i)); A(i == 0); A(NumberEqualsInt32(-0.0, &i)); A(i == 0); A(NumberIsInt32(double(INT32_MIN), &i)); A(i == INT32_MIN); A(NumberIsInt32(double(INT32_MAX), &i)); A(i == INT32_MAX); A(NumberEqualsInt32(double(INT32_MIN), &i)); A(i == INT32_MIN); A(NumberEqualsInt32(double(INT32_MAX), &i)); A(i == INT32_MAX); A(!NumberIsInt32(0.5, &i)); A(!NumberIsInt32(double(INT32_MAX) + 0.1, &i)); A(!NumberIsInt32(double(INT32_MIN) - 0.1, &i)); A(!NumberIsInt32(NegativeInfinity<double>(), &i)); A(!NumberIsInt32(PositiveInfinity<double>(), &i)); A(!NumberIsInt32(UnspecifiedNaN<double>(), &i)); A(!NumberEqualsInt32(0.5, &i)); A(!NumberEqualsInt32(double(INT32_MAX) + 0.1, &i)); A(!NumberEqualsInt32(double(INT32_MIN) - 0.1, &i)); A(!NumberEqualsInt32(NegativeInfinity<double>(), &i)); A(!NumberEqualsInt32(PositiveInfinity<double>(), &i)); A(!NumberEqualsInt32(UnspecifiedNaN<double>(), &i)); } static void TestFloatsPredicates() { A(IsNaN(UnspecifiedNaN<float>())); A(IsNaN(SpecificNaN<float>(1, 17)));; A(IsNaN(SpecificNaN<float>(0, 0x7fff0fUL))); A(!IsNaN(0.0f)); A(!IsNaN(-0.0f)); A(!IsNaN(1.0f)); A(!IsNaN(PositiveInfinity<float>())); A(!IsNaN(NegativeInfinity<float>())); A(IsInfinite(PositiveInfinity<float>())); A(IsInfinite(NegativeInfinity<float>())); A(!IsInfinite(UnspecifiedNaN<float>())); A(!IsInfinite(0.0f)); A(!IsInfinite(-0.0f)); A(!IsInfinite(1.0f)); A(!IsFinite(PositiveInfinity<float>())); A(!IsFinite(NegativeInfinity<float>())); A(!IsFinite(UnspecifiedNaN<float>())); A(IsFinite(0.0f)); A(IsFinite(-0.0f)); A(IsFinite(1.0f)); A(!IsNegative(PositiveInfinity<float>())); A(IsNegative(NegativeInfinity<float>())); A(IsNegative(-0.0f)); A(!IsNegative(0.0f)); A(IsNegative(-1.0f)); A(!IsNegative(1.0f)); A(!IsNegativeZero(PositiveInfinity<float>())); A(!IsNegativeZero(NegativeInfinity<float>())); A(!IsNegativeZero(SpecificNaN<float>(1, 17)));; A(!IsNegativeZero(SpecificNaN<float>(1, 0x7fff0fUL))); A(!IsNegativeZero(SpecificNaN<float>(0, 17)));; A(!IsNegativeZero(SpecificNaN<float>(0, 0x7fff0fUL))); A(!IsNegativeZero(UnspecifiedNaN<float>())); A(IsNegativeZero(-0.0f)); A(!IsNegativeZero(0.0f)); A(!IsNegativeZero(-1.0f)); A(!IsNegativeZero(1.0f)); A(!IsPositiveZero(PositiveInfinity<float>())); A(!IsPositiveZero(NegativeInfinity<float>())); A(!IsPositiveZero(SpecificNaN<float>(1, 17)));; A(!IsPositiveZero(SpecificNaN<float>(1, 0x7fff0fUL))); A(!IsPositiveZero(SpecificNaN<float>(0, 17)));; A(!IsPositiveZero(SpecificNaN<float>(0, 0x7fff0fUL))); A(!IsPositiveZero(UnspecifiedNaN<float>())); A(IsPositiveZero(0.0f)); A(!IsPositiveZero(-0.0f)); A(!IsPositiveZero(-1.0f)); A(!IsPositiveZero(1.0f)); int32_t i; const int32_t BIG = 2097151; A(NumberIsInt32(0.0f, &i)); A(i == 0); A(!NumberIsInt32(-0.0f, &i)); A(NumberEqualsInt32(0.0f, &i)); A(i == 0); A(NumberEqualsInt32(-0.0f, &i)); A(i == 0); A(NumberIsInt32(float(INT32_MIN), &i)); A(i == INT32_MIN); A(NumberIsInt32(float(BIG), &i)); A(i == BIG); A(NumberEqualsInt32(float(INT32_MIN), &i)); A(i == INT32_MIN); A(NumberEqualsInt32(float(BIG), &i)); A(i == BIG); A(!NumberIsInt32(0.5f, &i)); A(!NumberIsInt32(float(BIG) + 0.1f, &i)); A(!NumberIsInt32(NegativeInfinity<float>(), &i)); A(!NumberIsInt32(PositiveInfinity<float>(), &i)); A(!NumberIsInt32(UnspecifiedNaN<float>(), &i)); A(!NumberEqualsInt32(0.5f, &i)); A(!NumberEqualsInt32(float(BIG) + 0.1f, &i)); A(!NumberEqualsInt32(NegativeInfinity<float>(), &i)); A(!NumberEqualsInt32(PositiveInfinity<float>(), &i)); A(!NumberEqualsInt32(UnspecifiedNaN<float>(), &i)); } static void TestPredicates() { TestFloatsPredicates(); TestDoublesPredicates(); } static void TestFloatsAreApproximatelyEqual() { float epsilon = mozilla::detail::FuzzyEqualsEpsilon<float>::value(); float lessThanEpsilon = epsilon / 2.0f; float moreThanEpsilon = epsilon * 2.0f; // Additive tests using the default epsilon // ... around 1.0 A(FuzzyEqualsAdditive(1.0f, 1.0f + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0f, 1.0f - lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0f, 1.0f + epsilon)); A(FuzzyEqualsAdditive(1.0f, 1.0f - epsilon)); A(!FuzzyEqualsAdditive(1.0f, 1.0f + moreThanEpsilon)); A(!FuzzyEqualsAdditive(1.0f, 1.0f - moreThanEpsilon)); // ... around 1.0e2 (this is near the upper bound of the range where // adding moreThanEpsilon will still be representable and return false) A(FuzzyEqualsAdditive(1.0e2f, 1.0e2f + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0e2f, 1.0e2f + epsilon)); A(!FuzzyEqualsAdditive(1.0e2f, 1.0e2f + moreThanEpsilon)); // ... around 1.0e-10 A(FuzzyEqualsAdditive(1.0e-10f, 1.0e-10f + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0e-10f, 1.0e-10f + epsilon)); A(!FuzzyEqualsAdditive(1.0e-10f, 1.0e-10f + moreThanEpsilon)); // ... straddling 0 A(FuzzyEqualsAdditive(1.0e-6f, -1.0e-6f)); A(!FuzzyEqualsAdditive(1.0e-5f, -1.0e-5f)); // Using a small epsilon A(FuzzyEqualsAdditive(1.0e-5f, 1.0e-5f + 1.0e-10f, 1.0e-9f)); A(!FuzzyEqualsAdditive(1.0e-5f, 1.0e-5f + 1.0e-10f, 1.0e-11f)); // Using a big epsilon A(FuzzyEqualsAdditive(1.0e20f, 1.0e20f + 1.0e15f, 1.0e16f)); A(!FuzzyEqualsAdditive(1.0e20f, 1.0e20f + 1.0e15f, 1.0e14f)); // Multiplicative tests using the default epsilon // ... around 1.0 A(FuzzyEqualsMultiplicative(1.0f, 1.0f + lessThanEpsilon)); A(FuzzyEqualsMultiplicative(1.0f, 1.0f - lessThanEpsilon)); A(FuzzyEqualsMultiplicative(1.0f, 1.0f + epsilon)); A(!FuzzyEqualsMultiplicative(1.0f, 1.0f - epsilon)); A(!FuzzyEqualsMultiplicative(1.0f, 1.0f + moreThanEpsilon)); A(!FuzzyEqualsMultiplicative(1.0f, 1.0f - moreThanEpsilon)); // ... around 1.0e10 A(FuzzyEqualsMultiplicative(1.0e10f, 1.0e10f + (lessThanEpsilon * 1.0e10f))); A(!FuzzyEqualsMultiplicative(1.0e10f, 1.0e10f + (moreThanEpsilon * 1.0e10f))); // ... around 1.0e-10 A(FuzzyEqualsMultiplicative(1.0e-10f, 1.0e-10f + (lessThanEpsilon * 1.0e-10f))); A(!FuzzyEqualsMultiplicative(1.0e-10f, 1.0e-10f + (moreThanEpsilon * 1.0e-10f))); // ... straddling 0 A(!FuzzyEqualsMultiplicative(1.0e-6f, -1.0e-6f)); A(FuzzyEqualsMultiplicative(1.0e-6f, -1.0e-6f, 1.0e2f)); // Using a small epsilon A(FuzzyEqualsMultiplicative(1.0e-5f, 1.0e-5f + 1.0e-10f, 1.0e-4f)); A(!FuzzyEqualsMultiplicative(1.0e-5f, 1.0e-5f + 1.0e-10f, 1.0e-5f)); // Using a big epsilon A(FuzzyEqualsMultiplicative(1.0f, 2.0f, 1.0f)); A(!FuzzyEqualsMultiplicative(1.0f, 2.0f, 0.1f)); // "real world case" float oneThird = 10.0f / 3.0f; A(FuzzyEqualsAdditive(10.0f, 3.0f * oneThird)); A(FuzzyEqualsMultiplicative(10.0f, 3.0f * oneThird)); // NaN check A(!FuzzyEqualsAdditive(SpecificNaN<float>(1, 1), SpecificNaN<float>(1, 1))); A(!FuzzyEqualsAdditive(SpecificNaN<float>(1, 2), SpecificNaN<float>(0, 8))); A(!FuzzyEqualsMultiplicative(SpecificNaN<float>(1, 1), SpecificNaN<float>(1, 1))); A(!FuzzyEqualsMultiplicative(SpecificNaN<float>(1, 2), SpecificNaN<float>(0, 200))); } static void TestDoublesAreApproximatelyEqual() { double epsilon = mozilla::detail::FuzzyEqualsEpsilon<double>::value(); double lessThanEpsilon = epsilon / 2.0; double moreThanEpsilon = epsilon * 2.0; // Additive tests using the default epsilon // ... around 1.0 A(FuzzyEqualsAdditive(1.0, 1.0 + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0, 1.0 - lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0, 1.0 + epsilon)); A(FuzzyEqualsAdditive(1.0, 1.0 - epsilon)); A(!FuzzyEqualsAdditive(1.0, 1.0 + moreThanEpsilon)); A(!FuzzyEqualsAdditive(1.0, 1.0 - moreThanEpsilon)); // ... around 1.0e4 (this is near the upper bound of the range where // adding moreThanEpsilon will still be representable and return false) A(FuzzyEqualsAdditive(1.0e4, 1.0e4 + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0e4, 1.0e4 + epsilon)); A(!FuzzyEqualsAdditive(1.0e4, 1.0e4 + moreThanEpsilon)); // ... around 1.0e-25 A(FuzzyEqualsAdditive(1.0e-25, 1.0e-25 + lessThanEpsilon)); A(FuzzyEqualsAdditive(1.0e-25, 1.0e-25 + epsilon)); A(!FuzzyEqualsAdditive(1.0e-25, 1.0e-25 + moreThanEpsilon)); // ... straddling 0 A(FuzzyEqualsAdditive(1.0e-13, -1.0e-13)); A(!FuzzyEqualsAdditive(1.0e-12, -1.0e-12)); // Using a small epsilon A(FuzzyEqualsAdditive(1.0e-15, 1.0e-15 + 1.0e-30, 1.0e-29)); A(!FuzzyEqualsAdditive(1.0e-15, 1.0e-15 + 1.0e-30, 1.0e-31)); // Using a big epsilon A(FuzzyEqualsAdditive(1.0e40, 1.0e40 + 1.0e25, 1.0e26)); A(!FuzzyEqualsAdditive(1.0e40, 1.0e40 + 1.0e25, 1.0e24)); // Multiplicative tests using the default epsilon // ... around 1.0 A(FuzzyEqualsMultiplicative(1.0, 1.0 + lessThanEpsilon)); A(FuzzyEqualsMultiplicative(1.0, 1.0 - lessThanEpsilon)); A(FuzzyEqualsMultiplicative(1.0, 1.0 + epsilon)); A(!FuzzyEqualsMultiplicative(1.0, 1.0 - epsilon)); A(!FuzzyEqualsMultiplicative(1.0, 1.0 + moreThanEpsilon)); A(!FuzzyEqualsMultiplicative(1.0, 1.0 - moreThanEpsilon)); // ... around 1.0e30 A(FuzzyEqualsMultiplicative(1.0e30, 1.0e30 + (lessThanEpsilon * 1.0e30))); A(!FuzzyEqualsMultiplicative(1.0e30, 1.0e30 + (moreThanEpsilon * 1.0e30))); // ... around 1.0e-30 A(FuzzyEqualsMultiplicative(1.0e-30, 1.0e-30 + (lessThanEpsilon * 1.0e-30))); A(!FuzzyEqualsMultiplicative(1.0e-30, 1.0e-30 + (moreThanEpsilon * 1.0e-30))); // ... straddling 0 A(!FuzzyEqualsMultiplicative(1.0e-6, -1.0e-6)); A(FuzzyEqualsMultiplicative(1.0e-6, -1.0e-6, 1.0e2)); // Using a small epsilon A(FuzzyEqualsMultiplicative(1.0e-15, 1.0e-15 + 1.0e-30, 1.0e-15)); A(!FuzzyEqualsMultiplicative(1.0e-15, 1.0e-15 + 1.0e-30, 1.0e-16)); // Using a big epsilon A(FuzzyEqualsMultiplicative(1.0e40, 2.0e40, 1.0)); A(!FuzzyEqualsMultiplicative(1.0e40, 2.0e40, 0.1)); // "real world case" double oneThird = 10.0 / 3.0; A(FuzzyEqualsAdditive(10.0, 3.0 * oneThird)); A(FuzzyEqualsMultiplicative(10.0, 3.0 * oneThird)); // NaN check A(!FuzzyEqualsAdditive(SpecificNaN<double>(1, 1), SpecificNaN<double>(1, 1))); A(!FuzzyEqualsAdditive(SpecificNaN<double>(1, 2), SpecificNaN<double>(0, 8))); A(!FuzzyEqualsMultiplicative(SpecificNaN<double>(1, 1), SpecificNaN<double>(1, 1))); A(!FuzzyEqualsMultiplicative(SpecificNaN<double>(1, 2), SpecificNaN<double>(0, 200))); } static void TestAreApproximatelyEqual() { TestFloatsAreApproximatelyEqual(); TestDoublesAreApproximatelyEqual(); } #undef A int main() { TestAreIdentical(); TestExponentComponent(); TestPredicates(); TestAreApproximatelyEqual(); return 0; }