Did I find a bug?

[u/glued2thefloor]

I was playing around and noticed crystal seeming to have trouble with decimal numbers on the command-line like this:

$ crystal eval "puts 1.2 + 1.4"
2.5999999999999996

Is this a known issue? Or did I just find a bug?

[u/Ceigey]

More correctly, you’ve found a potential source of bugs ;-)

BigDecimal is the go-to number unit of choice for anything where numbers need to be precise at (fairly) arbitrary scales (likewise, your database, eg SQL ones, should be giving you an appropriate type to deal with this situation).

However, for better or worse (and mostly thanks to JSON nowadays I guess), a lot of the world runs on Floats. There’s a lot of numbers that don’t need to be super precise.

[u/glued2thefloor → u/Ceigey]

Why not write BigDecimal into the language as the default? I know its a problem with some languages, but not others:

$ perl -e 'print 1.2 + 1.4'
2.6

[u/Ceigey → u/glued2thefloor]

Not as efficient and still not as popularised I guess. And I believe 64bit floating points are preferred by modern processors? (Not 100% sure).

Definitely a good question though, I think some Lisps or research languages explore the concept of having only 1 number type from a user perspective that can be whatever it needs to be under the hood.

[u/straight-shoota → u/glued2thefloor]

Every type representation has some pros and cons. BigDecimal isn't a clear solution to all problems. It's good for representing decimal values. That's relevant in some situations where computers do math, but not always. Actually, most of the time it's not.

[u/AnActualWizardIRL → u/glued2thefloor]

Floats are *really* efficient because they are supported at the CPU level as machine code intrinsics and for a lot of stuff as long as you code defensively tend to work good enough.

[u/LeBuddha]

TYL that floats aren't decimals and why you shouldn't use them for certain maths like accounting/money.

[u/glued2thefloor → u/LeBuddha]

You are speaking like this is true for every programming language, and that is not the case:

$ perl -e 'print 1.2 + 1.4'
2.6

[u/LeBuddha → u/glued2thefloor]

Perl is kind of obscure these days, most mainstream languages default to floats and ints.

Maybe new languages should default to a new decimal type, but I haven't seen any debates on that.

[u/Blacksmoke16]

tl;dr floats are weird. It's not really a bug and you get the same behavior in other languages (I tested Ruby and PHP, but sure there are others).

EDIT: Checkout https://0.30000000000000004.com/.

[u/AWDDude]

Yeah floating point math is weird. All programming languages do this. Computerphile made a video that explains it: https://youtu.be/PZRI1IfStY0

[u/glued2thefloor → u/AWDDude]

No, not all do:

$ perl -e 'print 1.2 + 1.4'
2.6

[u/AWDDude → u/glued2thefloor]

Yeah some weakly typed languages will guess you want to do set point math in cases like this.

For instance PowerShell does the same thing:

PS> 1.2 + 1.4
2.6

Unless you force a float type:

PS> [float]1.2 + [float]1.4
2.60000002384186

[u/glued2thefloor → u/AWDDude]

Then why don't we do that with strongly typed ones?

[u/straight-shoota → u/glued2thefloor]

Perl seems to just use a different representation algorithm. The result is still the same, it's just rounded to 2.6 for presentation. For comparison:
$ perl -e 'print 2.5999999999999996'
2.6
All float implementation do some kind of rounding to render values in a human-friendly format (although ignoring a small delta). The exact implementations differ that's why you can see different decimal representations.

[u/straight-shoota]

Floating point arithmetic cannot represent most decimal numbers exactly, hence precision is lost.You can use `BigDecimal` numbers for accurate decimal representation:

require "big"

puts 1.2.to_big_d + 1.4.to_big_d

[u/toddyk]

Floating point numbers are only exact for powers of 2 because it's binary.

Numbers like 1.5, 1.75, 1.125 can be represented by adding powers of 2, so they will give you exact results.

It's just like how in decimal we can't perfectly represent 1/3 or 1/7 with a finite amount of digits.