this post was submitted on 26 Feb 2024
752 points (95.7% liked)

Programmer Humor

20039 readers
1014 users here now

Welcome to Programmer Humor!

This is a place where you can post jokes, memes, humor, etc. related to programming!

For sharing awful code theres also Programming Horror.

Rules

founded 2 years ago
MODERATORS
 
you are viewing a single comment's thread
view the rest of the comments
[–] [email protected] 26 points 11 months ago (5 children)

I know this is in jest, but if 0.1+0.2!=0.3 hasn't caught you out at least once, then you haven't even done any programming.

[–] [email protected] 8 points 11 months ago

Me making my first calculator in c.

[–] [email protected] 8 points 11 months ago

IMO they should just remove the equality operator on floats.

[–] dylanTheDeveloper 7 points 11 months ago

what if i add more =

[–] [email protected] 5 points 11 months ago

That should really be written as the gamma function, because factorial is only defined for members of Z. /s

[–] [email protected] 1 points 1 week ago

But that's not because floats are inaccurate. A very very pedantic compiler wouldn't even let you write f64 x = 0.1; because 0.1 (and also 0.2 and 0.3) can't be converted to a float exactly (note that 0.5, 0.25, 0.125, etc. can be stored exactly!)

The moment you write f64 x = 0.1; and expect the computer to store that inside a float you already made a wrong assumption. What the computer actually stores is the float value that is as close as possible to 0.1. But not because floats are inaccurate, but because floats are base 2. Note that floating point types in general don't have to be base 2 - they can be any base (for example decimal types are base 10) but IEEE754 floats are base 2, because it allows for simpler hardware implementations.

An even more pedantic compiler would only let you write floating point in binary like 10.10110001b and let you do the conversation, because it would make it blatantly obvious that most base 10 decimals can't even be converted without information loss. So the "inaccuracy" is not(!) because float calculations are inaccurate but because many people wrongly assume that the base 10 literal they wrote can be stored inside a float.

Floats are actually really accurate (ignoring some Intel FPU hardware bugs). I skipped a lot of details which you can find here: https://zeta.one/floats-are-not-inaccurate/

Equipped with that knowledge your calculation 0.1+0.2 != 0.3 can simply be translated into: "The closest float to 0.1" + "The closest float to 0.2" is not equal to "The closest float to 0.3". Keep in mind that the addition itself is perfectly accurate and without any error/rounding(!) on every EEE754 conforming implementation.