text: //========= 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;
  }
  
  
  