0.1 + 0.2 = 0.30000000000000004 ?

[quanxufeng]

Node.js v16.17.0.

const {chain,evaluate} = require('mathjs');
undefined

chain('0.1')
Chain { value: '0.1' }
chain('0.1').add(0.2)
Chain { value: 0.30000000000000004 }

[josdejong]

This is the most asked question. This is a round-off error.

Docs: https://mathjs.org/docs/datatypes/numbers.html#roundoff-errors
Similar questions: https://github.com/josdejong/mathjs/issues?q=is%3Aissue+round-off+is%3Aclosed

[lulunac27a]

These numbers are based on double-precision floating-point numbers.

[gwhitney]

@josdejong should we put a question in Discussions with an accepted answer for this (would be nice if we could "pin" FAQs there), and/or put something in the issue template (is there one now?) that mentions a list of common questions not to post? Seems like this comes up almost every other week and it's a waste of time.

[josdejong]

👍 yes will do, I forgot about this not being in the Discussions section.

[jinceon]

I always use math.simpilfy to solve this problem.

a=0.1,b=0.2;
print(math.evaluate('0.1+0.2'))
// 0.30000000000000004
print(math.simplify('0.1+0.2'))
// 3/10
print(math.evaluate(math.simplify('0.1+0.2')))
// 0.3

[gwhitney]

This is a very interesting approach, and thank you for sharing your ideas.

I just want to point out that simplify here is essentially working as a roundabout way to have the inputs be considered as exact fractions (rational numbers).

The main underlying point is that the rational number 3/10 has no exact representation as a finite binary expression, much the way that 1/3 has no exact finite decimal representation. Neither do 1/10 or 2/10. So the floating point arithmetic must choose an approximation to each of these numbers, and it is not a big surprise that the floating-point sum of the approximations chosen for 1/10 and 2/10 doesn't happen to be the approximation chosen for 3/10.

On the other hand, simplify does check decimal inputs to see if they seem to arise from low-denominator rational numbers, and if so works with the exact rationals instead. But if you know you are working with exact rational numbers, you should very likely use the Fraction data type instead, which performs exact arbitrary-precision rational arithmetic:

print(math.evaluate('fraction(1,10) + fraction(2,10)') 
// 3/10
print(math.evaluate('number(fraction(3,10))'))
// 0.3

So one moral of the story is when possible evaluate with exact mathematical representations and convert to (JavaScript floating-point) numbers as late as possible. There are also other ways besides simplify to get mathjs to consider inputs like 0.15 to be the exact fraction 15/100. For example, as noted on the Fractions doc page, you can do:

math.config({
  number: 'Fraction'
})
print(math.evaluate('0.1 + 0.2')) // Prints  3/10