This same issue happens with every single language that has floating point numbers. The IEEE standard means that everyone does these calculations in the same way with the same (very good) set of rules. But it’s impossible to remove the issue and still use binary floating point.

One common workaround is to round to the nearest 1/100th or 1/10000th, this is common in financial software. (More common than storing values in cents)

Another is to use vulgar fractions, either with the denominator as a power of 10 or the general form with any denominator. (This is common in BIG NUMBER packages)

But none of these (including the IEEE 754) is a simple solution; that’s one of the reasons why IEEE 754 is as common as it is, there’s a lot of work gone into that standard.

They are all using floats underneath. But lua is using a different sprintf string to represent the numbers. This is potentially confusing, but it is also nice in other ways.

Example:
lua> print(0.1 + 0.2)
0.3
lua> print((0.1 + 0.2) == 0.3)
false

This is because Lua is using the sprintf format: “%.14g”

It seems python and JavaScript use “%.17f” or something similar.

Now I understand. Comment to myself when I was coloring myself confused; floats are binary exponents, not decimal.

I think that probably replacing JavaScript numbers with something like perl’s arbitrary precision number would be best.

Code using workarounds for floats, such as (0.1 + 0.2 – 0.3 < 0.00001), would still work. And naive code would work correctly.

Ciao!

I’ve looked in the Lua code and I don’t see why it would be different, though I haven’t exhausted the lua source yet.

Did you read the Lua article?

Ciao!

floats are usually stored as: NNNN x 10^^POW


For the above example it should be something like:

1 x10^-1 + 2 x10^-1 = 3 x10^-1

How on earth is it being stored that there is noise like that?

Lua, for example, uses only floating point[1] and it can handle 0.1 + 0.2 = 0.3 just fine.

Ciao!

[1] http://lua-users.org/wiki/FloatingPoint

Instead, you ask if 0.1 + 0.2 – 0.3 < 0.00001 (or some other suitably small number). This works for all real-world cases where you’d use a float. It isn’t that big a deal. Please do not flame me with complaints that it increases download size.

http://stz-ida.de/html/oss/js_bigdecimal.html.en

Source code

http://stz-ida.de/download/oss/js_bigdecimal.tgz


var add = function (a, b) {
return Math.round((a + b) * 100)/100;
};


array.reduce(add, 0) now produces 100 instead of 100.00000000001425

The link points to another bibliography link that is broken…

With JavaScript gaining more and more importance these days, it seems to me that the real solution is to update to a more intelligent yet backwardly compatible numbering system.