Testing for NaN and Infinity values

From my work on pcsx2 I have had to deal extensively with the problem of NaN and Infinity values with floats.

The ps2's FPU and VU processors do not support NaN or Infinity values, so it is a pain to emulate them on a system that does support such values (x86-32/SSE processors).

There are a variety of ways to test for NaN and Infinity values, and I will list a few here.

The first is pretty well known.
If you compare a float for equality against itself, it should return True unless the float is a NaN.
So the typical approach is to do something like:

// Test for NaN
bool isNaN(float x) {
    return x != x;
}

That will only test for NaN's, if you want to check for infinities you can do something like this:

#include <limits>
#include <math.h>

// Test for positive or negative infinity values
bool isInf(float x) {
    return fabs(x) == numeric_limits<float>::infinity();
}

You can instead use bitwise logic to test for NaN's and Infinities.

// Test for NaN with bitwise logic
bool isNaN(float x) {
    return ((int&)x & 0x7fffffff) >= 0x7f800001;
}

// Test for Inf with bitwise logic
bool isInf(float x) {
    return ((int&)x & 0x7fffffff) == 0x7f800000;
}

You can even check for both NaN and Infinities with just one comparison:

// Test for NaN or Inf with bitwise logic
bool isNaNorInf(float x) {
    return ((int&)x & 0x7fffffff) >= 0x7f800000;
}

Generally you probably don't want to use the bitwise version of these functions for the reason that the compiled code will end up having to switch from FPU to integer arithmetic, which will most likely end up being slower than sticking to the floating point comparisons.