Bit Patterns of Float

https://quuxplusone.github.io/blog/2021/09/05/float-format/

by ingve • 5 years ago

103 31 5 years ago

quuxplusone.github.io

dvt3• 5 years ago

I'm not sure why the IEEE's original floating point specs didn't manage to make the NaN "quiet" (position 22) bit be the the leading "sign" bit -- although I'm sure there's a good reason. The NaN vs -NaN distinction is purely representative and has no semantic implications. As opposed to negative infinity or negative zero, for example.

Also worth adding is that NaN comparisons will break catastrophically when using gcc's -ffast-math`.

pklausler2• 5 years ago

There's no standard bit position for that flag, unfortunately, or even a standard interpretation (flag set -> quiet/signaling). A NaN just have to have at least one bit set in its significand to distinguish the NaN from an infinity.

(So the fact that a binary value is a NaN is portable, but not the distinction between qNaN and sNaN.)

dbaupp4• 5 years ago

I think that’s not the full story. The standard says:

A quiet NaN bit string should be encoded with the first bit (d1) of the trailing significand field T being 1. A signaling NaN bit string should be encoded with the first bit of the trailing significand field being 0

That does use “should” (not “shall”) and is described as a “preferred encoding”, so it’s standards-compliant to do something else, but it’s not recommended.

lazulicurio2• 5 years ago

Probably so if you bitcast a floating point value into a signed int it maintains the proper sign for comparisons.

saagarjha• 5 years ago

Yeah, but why have a signed NaN at all? It’s not like they have a defined ordering anyways…

dvt3• 5 years ago

I think casting a NaN to an int will always just return gibberish, signed or not. In fact, this is explicitly undefined behavior in C.

dbaupp4• 5 years ago

This would mean hardware/software tricks like those below wouldn’t work directly and would need additional gates/operations, because they’d noticeably change the meaning of NaNs.

   -x     => x xor 0b100…00
   abs(x) => x and 0b011…11

dvt3• 5 years ago

Yeah, I'm sure plenty of things would break, though I don't really think the IEEE was thinking of bit-twiddling trickery when they were writing the spec.

Const-me• 5 years ago

I've learned most of these things while writing SIMD code in C++. PC processors have very fast bitwise instructions processing fp32 and fp64 vectors, like andnps, xorpd, and the rest of them.

lazulicurio2• 5 years ago

A "fun" thing to do if you really want to get a hang of IEEE floats is manually write the algorithms for a bunch of rounding operations (ceil, floor, truncate, half to even, etc).

ddtaylor• 5 years ago

Zero is all-bits-zero. Its biased exponent is 00000000, or 127−127. ... 2^-127

Isn't 127-127 = 0, so it should be 2^0

guitarbill• 5 years ago

If you want to describe how to get the bit pattern, that's the calculation based on the known exponent. So because 127 - 127 = 0, the bit pattern is zeros. Not the other way around ;)

ajnin• 5 years ago

The "biased" exponent has a constant 127 added to it, so for example if the bits are 00000000 the exponent is actually 0-127=-127, if the bits are 10000111 the exponent is 135-127=8, and so forth.

arthur2e5• 5 years ago

I believe the IEEE 754 total ordering is identical to a classical recipe for fast FP comparison.[1] Of course, the handling of NaNs is only identical when the qNaN bit is at the MSB of the significand as recommended.

[1] http://stereopsis.com/radix.html

infogulch• 5 years ago

Apparently the bit pattern of a float interpreted as an int is sorta-kinda it's own logarithm, which is why the famous fast inverse square root from quake 3 works: log(x^-½) = -½log(x) =~ -log(x) >> 1. This video is approachable and explains it pretty well: https://www.youtube.com/watch?v=p8u_k2LIZyo

thegeomaster• 5 years ago

I can't recommend https://float.exposed enough. A great tool for exploring floating-point representations.

nickcw• 5 years ago

For anyone that read the code at the end of this article and was wondering what the spaceship / flying saucer operator <=> was doing in a C++ program, I found a write up on this on stack overflow page:

https://stackoverflow.com/a/47466459/164234

According to that, this was added in C++20 and means

There’s a new three-way comparison operator, <=>. The expression a <=> b returns an object that compares <0 if a < b, compares >0 if a > b, and compares ==0 if a and b are equal/equivalent.

I first saw this in Perl a long time ago and according to Wikipedia it is in Perl, Ruby, Apache Groovy, PHP, Eclipse Ceylon as well as C++ now.

https://en.wikipedia.org/wiki/Three-way_comparison

Bit Patterns of Float

Related Stories