Essentially all architectures in current non-punch-card use, including embedded architectures and exotic signal processing architectures, offer one of two floating point systems:
- IEEE-754.
- IEEE-754 except for blah. That is, they mostly implement 754, but cheap out on some of the more expensive and/or fiddly bits.
The most common cheap-outs:
- Flushing denormals to zero. This invalidates certain sometimes-useful theorems (in particular, the theorem that
a-b
can be exactly represented ifa
andb
are within a factor of 2), but in practice it’s generally not going to be an issue. - Failure to recognize
inf
andNaN
as special. These architectures will fail to follow the rules regardinginf
andNaN
as operands, and may not saturate toinf
, instead producing numbers that are larger thanFLT_MAX
, which will generally be recognized by other architectures asNaN
. - Proper rounding of division and square root. It’s a whole lot easier to guarantee that the result is within 1-3 ulps of the exact result than within 1/2 ulp. A particularly common case is for division to be implemented as reciprocal+multiplication, which loses you one bit of precision.
- Fewer or no guard digits. This is an unusual cheap-out, but means that other operations can be 1-2 ulps off.
BUUUUT… even those except for blah architectures still use IEEE-754’s representation of numbers. Other than byte ordering issues, the bits describing a float
or double
on architecture A are essentially guaranteed to have the same meaning on architecture B.
So as long as all you care about is the representation of values, you’re totally fine. If you care about cross-platform consistency of operations, you may need to do some extra work.
EDIT: As Chux mentions in the comments, a common extra source of inconsistency between platforms is the use of extended precision, such as the x87’s 80-bit internal representation. That’s the opposite of a cheap-out, and (with proper treatment) fully conforms to both IEEE-754 and the C standard, but it will likewise cause results to differ between architectures, and even between compiler versions and following apparently minor and unrelated code changes. However: a particular x86/x64 executable will NOT produce different results on different processors due to extended precision.