From f56bb35301836e56582a575a75864392a0177875 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20P=2E=20Tjern=C3=B8?= Date: Mon, 2 Dec 2013 19:31:46 -0800 Subject: Fix line endings. WHAMMY. --- sp/src/mathlib/almostequal.cpp | 194 ++++++++++++++++++++--------------------- 1 file changed, 97 insertions(+), 97 deletions(-) (limited to 'sp/src/mathlib/almostequal.cpp') diff --git a/sp/src/mathlib/almostequal.cpp b/sp/src/mathlib/almostequal.cpp index d4d3fba2..53b8a9e3 100644 --- a/sp/src/mathlib/almostequal.cpp +++ b/sp/src/mathlib/almostequal.cpp @@ -1,97 +1,97 @@ -//========= Copyright Valve Corporation, All rights reserved. ============// -// -// Purpose: Fast ways to compare equality of two floats. Assumes -// sizeof(float) == sizeof(int) and we are using IEEE format. -// -// Source: http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm -//=====================================================================================// - -#include -#include - -#include "mathlib/mathlib.h" - -static inline bool AE_IsInfinite(float a) -{ - const int kInfAsInt = 0x7F800000; - - // An infinity has an exponent of 255 (shift left 23 positions) and - // a zero mantissa. There are two infinities - positive and negative. - if ((*(int*)&a & 0x7FFFFFFF) == kInfAsInt) - return true; - return false; -} - -static inline bool AE_IsNan(float a) -{ - // a NAN has an exponent of 255 (shifted left 23 positions) and - // a non-zero mantissa. - int exp = *(int*)&a & 0x7F800000; - int mantissa = *(int*)&a & 0x007FFFFF; - if (exp == 0x7F800000 && mantissa != 0) - return true; - return false; -} - -static inline int AE_Sign(float a) -{ - // The sign bit of a number is the high bit. - return (*(int*)&a) & 0x80000000; -} - -// This is the 'final' version of the AlmostEqualUlps function. -// The optional checks are included for completeness, but in many -// cases they are not necessary, or even not desirable. -bool AlmostEqual(float a, float b, int maxUlps) -{ - // There are several optional checks that you can do, depending - // on what behavior you want from your floating point comparisons. - // These checks should not be necessary and they are included - // mainly for completeness. - - // If a or b are infinity (positive or negative) then - // only return true if they are exactly equal to each other - - // that is, if they are both infinities of the same sign. - // This check is only needed if you will be generating - // infinities and you don't want them 'close' to numbers - // near FLT_MAX. - if (AE_IsInfinite(a) || AE_IsInfinite(b)) - return a == b; - - // If a or b are a NAN, return false. NANs are equal to nothing, - // not even themselves. - // This check is only needed if you will be generating NANs - // and you use a maxUlps greater than 4 million or you want to - // ensure that a NAN does not equal itself. - if (AE_IsNan(a) || AE_IsNan(b)) - return false; - - // After adjusting floats so their representations are lexicographically - // ordered as twos-complement integers a very small positive number - // will compare as 'close' to a very small negative number. If this is - // not desireable, and if you are on a platform that supports - // subnormals (which is the only place the problem can show up) then - // you need this check. - // The check for a == b is because zero and negative zero have different - // signs but are equal to each other. - if (AE_Sign(a) != AE_Sign(b)) - return a == b; - - int aInt = *(int*)&a; - // Make aInt lexicographically ordered as a twos-complement int - if (aInt < 0) - aInt = 0x80000000 - aInt; - // Make bInt lexicographically ordered as a twos-complement int - int bInt = *(int*)&b; - if (bInt < 0) - bInt = 0x80000000 - bInt; - - // Now we can compare aInt and bInt to find out how far apart a and b - // are. - int intDiff = abs(aInt - bInt); - if (intDiff <= maxUlps) - return true; - return false; -} - - +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Fast ways to compare equality of two floats. Assumes +// sizeof(float) == sizeof(int) and we are using IEEE format. +// +// Source: http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm +//=====================================================================================// + +#include +#include + +#include "mathlib/mathlib.h" + +static inline bool AE_IsInfinite(float a) +{ + const int kInfAsInt = 0x7F800000; + + // An infinity has an exponent of 255 (shift left 23 positions) and + // a zero mantissa. There are two infinities - positive and negative. + if ((*(int*)&a & 0x7FFFFFFF) == kInfAsInt) + return true; + return false; +} + +static inline bool AE_IsNan(float a) +{ + // a NAN has an exponent of 255 (shifted left 23 positions) and + // a non-zero mantissa. + int exp = *(int*)&a & 0x7F800000; + int mantissa = *(int*)&a & 0x007FFFFF; + if (exp == 0x7F800000 && mantissa != 0) + return true; + return false; +} + +static inline int AE_Sign(float a) +{ + // The sign bit of a number is the high bit. + return (*(int*)&a) & 0x80000000; +} + +// This is the 'final' version of the AlmostEqualUlps function. +// The optional checks are included for completeness, but in many +// cases they are not necessary, or even not desirable. +bool AlmostEqual(float a, float b, int maxUlps) +{ + // There are several optional checks that you can do, depending + // on what behavior you want from your floating point comparisons. + // These checks should not be necessary and they are included + // mainly for completeness. + + // If a or b are infinity (positive or negative) then + // only return true if they are exactly equal to each other - + // that is, if they are both infinities of the same sign. + // This check is only needed if you will be generating + // infinities and you don't want them 'close' to numbers + // near FLT_MAX. + if (AE_IsInfinite(a) || AE_IsInfinite(b)) + return a == b; + + // If a or b are a NAN, return false. NANs are equal to nothing, + // not even themselves. + // This check is only needed if you will be generating NANs + // and you use a maxUlps greater than 4 million or you want to + // ensure that a NAN does not equal itself. + if (AE_IsNan(a) || AE_IsNan(b)) + return false; + + // After adjusting floats so their representations are lexicographically + // ordered as twos-complement integers a very small positive number + // will compare as 'close' to a very small negative number. If this is + // not desireable, and if you are on a platform that supports + // subnormals (which is the only place the problem can show up) then + // you need this check. + // The check for a == b is because zero and negative zero have different + // signs but are equal to each other. + if (AE_Sign(a) != AE_Sign(b)) + return a == b; + + int aInt = *(int*)&a; + // Make aInt lexicographically ordered as a twos-complement int + if (aInt < 0) + aInt = 0x80000000 - aInt; + // Make bInt lexicographically ordered as a twos-complement int + int bInt = *(int*)&b; + if (bInt < 0) + bInt = 0x80000000 - bInt; + + // Now we can compare aInt and bInt to find out how far apart a and b + // are. + int intDiff = abs(aInt - bInt); + if (intDiff <= maxUlps) + return true; + return false; +} + + -- cgit v1.2.3