Do any real-world CPUs not use IEEE 754?

Question

I'm optimizing a sorting function for a numerics/statistics library based on the assumption that, after filtering out any NaNs and doing a little bit twiddling, floats can be compared as 32-bit ints without changing the result and doubles can be compared as 64-bit ints. This seems to speed up sorting these arrays by somewhere on the order of 40%, and my assumption holds as long as the bit-level representation of floating point numbers is IEEE 754. Are there any real-world CPUs that people actually use (excluding in embedded devices, which this library doesn't target) that use some other representation that might break this assumption?

Answer 1

Other than flawed Pentiums, any x86 or x64-based CPU is using IEEE 754 as their floating-point arithmetic standard.

Here are a brief overview of the FPA standards and their adoptions.

    IEEE 754:       Intel x86, and all RISC systems (IBM Power
                    and PowerPC, Compaq/DEC Alpha, HP PA-RISC,
                    Motorola 68xxx and 88xxx, SGI (MIPS) R-xxxx,
                    Sun SPARC, and others);

    VAX:            Compaq/DEC

    IBM S/390:      IBM (however, in 1998, IBM added an IEEE 754
                    option to S/390)

    Cray:           X-MP, Y-MP, C-90; other Cray models have been
                    based on Alpha and SPARC processors with
                    IEEE-754 arithmetic.

Unless your planning on supporting your library on fairly exotic CPU architectures, it is safe to assume that for now 99% of CPUs are IEEE 754 compliant.

Answer 2

The Cell Processor's SPUs differ in a few ways (like lack of INF and NANs), but I don't think there are differences would break your assumptions...

Answer 3

It depends on where you draw the line between the "real world" and the imaginary one.

1. Vax G format is still supported on Alpha machines (which HP says they will support through at least 2013).
2. IBM hexadecimal FP still supported by IBM z-series mainframes. They've added IEEE binary and decimal support, but from what I've heard they're rarely used, because the hexadecimal FP is quite a bit faster (IBM's been optimizing it for about 45 years now...)

Until fairly recently, Unisys still sold ClearPath IX serves that supported the Burroughs FP format, and ClearPath MCP machines to support the Univac FP format. I believe those are now only run in emulation (on Xeons) but from a software viewpoint, they'll probably continue in active use for another decade or more.

There are even a few people using DtCyber to run Plato on (emulated) Control Data mainframes, with their unique floating point format. (Sorry, but my first serious programming was on a CDC Cyber machine, so I couldn't resist bringing it up, even if it hasn't been "real world" for a decades).