Fix line endings. WHAMMY.

1 files changed, 97 insertions, 97 deletions

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 <float.h>

-#include <math.h>

-

-#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 <float.h>
+#include <math.h>
+
+#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;
+}
+
+