98 lines
3.4 KiB
C++
98 lines
3.4 KiB
C++
//========= 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;
|
|
}
|
|
|
|
|