Floating Point Math

Your language isn't broken, it's doing floating point math. Computers can only natively store integers, so they need some way of representing decimal numbers. This representation comes with some degree of inaccuracy. That's why, more often than not, .1 + .2 != .3.

Why does this happen?

It's actually pretty simple. When you have a base 10 system (like ours), it can only express fractions that use a prime factor of the base. The prime factors of 10 are 2 and 5. So 1/2, 1/4, 1/5, 1/8, and 1/10 can all be expressed cleanly because the denominators all use prime factors of 10. In contrast, 1/3, 1/6, and 1/7 are all repeating decimals because their denominators use a prime factor of 3 or 7. In binary (or base 2), the only prime factor is 2. So you can only express fractions cleanly which only contain 2 as a prime factor. In binary, 1/2, 1/4, 1/8 would all be expressed cleanly as decimals. While, 1/5 or 1/10 would be repeating decimals. So 0.1 and 0.2 (1/10 and 1/5) while clean decimals in a base 10 system, are repeating decimals in the base 2 system the computer is operating in. When you do math on these repeating decimals, you end up with leftovers which carry over when you convert the computer's base 2 (binary) number into a more human readable base 10 number.

Below are some examples of sending .1 + .2 to standard output in a variety of languages.

read more: | wikipedia | IEEE 754 | Stack Overflow | What Every Computer Scientist Should Know About Floating-Point Arithmetic

Language Code Result
ABAP
WRITE / CONV f( '.1' + '.2' ).
And
WRITE / CONV decfloat16( '.1' + '.2' ).

0.30000000000000004

And

0.3

Ada
with Ada.Text_IO; use Ada.Text_IO;
procedure Sum is
  A : Float := 0.1;
  B : Float := 0.2;
  C : Float := A + B;
begin
  Put_Line(Float'Image(C));
  Put_Line(Float'Image(0.1 + 0.2));
end Sum;

3.00000E-01
3.00000E-01

APL
0.1 + 0.2

0.30000000000000004

AutoHotkey
MsgBox, % 0.1 + 0.2

0.300000

awk
echo | awk '{ print 0.1 + 0.2 }'

0.3

bc
0.1 + 0.2

0.3

C
#include<stdio.h>
int main(int argc, char** argv) {
    printf("%.17f\n", .1+.2);
    return 0;
}

0.30000000000000004

Clojure
(+ 0.1 0.2)

0.30000000000000004

Clojure supports arbitrary precision and ratios. (+ 0.1M 0.2M) returns 0.3M, while (+ 1/10 2/10) returns 3/10.

ColdFusion
<cfset foo = .1 + .2>
<cfoutput>#foo#</cfoutput>

0.3

Common Lisp
* (+ .1 .2)
And
* (+ 1/10 2/10)
And
* (- 1.2 1.0)

0.3

And

3/10

And

0.20000005

C++
#include <iomanip>
std::cout << std::setprecision(17) << 0.1 + 0.2

0.30000000000000004

C#
Console.WriteLine("{0:R}", .1 + .2);
And
Console.WriteLine("{0:R}", .1m + .2m);

0.30000000000000004

And

0.3

C# has support for 128-bit decimal numbers, with 28-29 significant digits of precision. Their range, however, is smaller than that of both the single and double precision floating point types. Decimal literals are denoted with the m suffix.

D
import std.stdio;

void main(string[] args) {
  writefln("%.17f", .1+.2);
  writefln("%.17f", .1f+.2f);
  writefln("%.17f", .1L+.2L);
}

0.29999999999999999
0.30000001192092896
0.30000000000000000

Dart
print(.1 + .2);

0.30000000000000004

dc
0.1 0.2 + p

.3

Delphi XE5
writeln(0.1 + 0.2);

3.00000000000000E-0001

Elixir
IO.puts(0.1 + 0.2)

0.30000000000000004

Elm
0.1 + 0.2

0.30000000000000004

Emacs Lisp
(+ .1 .2)

0.30000000000000004

Erlang
io:format("~w~n", [0.1 + 0.2]).

0.30000000000000004

FORTRAN
program FLOATMATHTEST
  real(kind=4) :: x4, y4
  real(kind=8) :: x8, y8
  real(kind=16) :: x16, y16
  ! REAL literals are single precision, use _8 or _16
  ! if the literal should be wider.
  x4 = .1; x8 = .1_8; x16 = .1_16
  y4 = .2; y8 = .2_8; y16 = .2_16
  write (*,*) x4 + y4, x8 + y8, x16 + y16
end

0.300000012
0.30000000000000004
0.300000000000000000000000000000000039

Gforth
0.1e 0.2e f+ f.

0.3

GHC (Haskell)
* 0.1 + 0.2 :: Double
And
* 0.1 + 0.2 :: Float

* 0.30000000000000004

And

* 0.3

Haskell supports rational numbers. To get the math right, (1 % 10) + (2 % 10) returns 3 % 10.

Go
package main
import "fmt"
func main() {
  fmt.Println(.1 + .2)
  var a float64 = .1
  var b float64 = .2
  fmt.Println(a + b)
  fmt.Printf("%.54f\n", .1 + .2)
}

0.3
0.30000000000000004
0.299999999999999988897769753748434595763683319091796875

Go numeric constants have arbitrary precision.

Groovy
println 0.1 + 0.2

0.3

Literal decimal values in Groovy are instances of java.math.BigDecimal

Hugs (Haskell)
0.1 + 0.2

0.3

Io
(0.1 + 0.2) print

0.3

Java
System.out.println(.1 + .2);
And
System.out.println(.1F + .2F);

0.30000000000000004

And

0.3

Java has built-in support for arbitrary precision numbers using the BigDecimal class.

JavaScript
console.log(.1 + .2);

0.30000000000000004

The decimal.js library provides an arbitrary-precision Decimal type for JavaScript.

Julia
.1 + .2

0.30000000000000004

Julia has built-in rational numbers support and also a built-in arbitrary-precision BigFloat data type. To get the math right, 1//10 + 2//10 returns 3//10.

K (Kona)
0.1 + 0.2

0.3

Lua
print(.1 + .2)
And
print(string.format("%0.17f", 0.1 + 0.2))

0.3

And

0.30000000000000004

Mathematica
0.1 + 0.2

0.3

Mathematica has a fairly thorough internal mechanism for dealing with numerical precision and supports arbitrary precision.

Matlab
0.1 + 0.2
And
sprintf('%.17f',0.1+0.3)

0.3

And

0.30000000000000004

MySQL
SELECT .1 + .2;

0.3

Nim
echo(0.1 + 0.2)

0.3

Objective-C
0.1 + 0.2;

0.300000012

OCaml
0.1 +. 0.2;;

float = 0.300000000000000044

Perl 5
perl -E 'say 0.1+0.2'
And
perl -e 'printf q{%.17f}, 0.1+0.2'

0.3

And

0.30000000000000004

Perl 6
perl6 -e 'say 0.1+0.2'
And
perl6 -e 'say sprintf(q{%.17f}, 0.1+0.2)'
And
perl6 -e 'say 1/10+2/10'

0.3

And

0.3

And

0.3

Perl 6, unlike Perl 5, uses rationals by default, so .1 is stored something like { numerator => 1, denominator => 10 }.

PHP
echo .1 + .2;

0.3

PHP converts 0.30000000000000004 to a string and shortens it to “0.3”. To achieve the desired floating point result, adjust the precision ini setting: ini_set(“precision”, 17).

PicoLisp
[load "frac.min.l"]  # https://gist.github.com/DKordic/6016d743c4c124a1c04fc12accf7ef17
And
[println (+ (/ 1 10) (/ 2 10))]

(/ 3 10)

Postgres
SELECT select 0.1::float + 0.2::float;

0.3

Powershell
PS C:\>0.1 + 0.2

0.3

Prolog (SWI-Prolog)
?- X is 0.1 + 0.2.

X = 0.30000000000000004.

Pyret
0.1 + 0.2
And
~0.1 + ~0.2

0.3

And

~0.30000000000000004

Pyret has built-in support for both rational numbers and floating points. Numbers written normally are assumed to be exact. In contrast, RoughNums are represented by floating points, and are written with a ~ in front, to indicate that they are not precise answers. (The ~ is meant to visually evoke hand-waving.) Therefore, a user who sees a computation produce ~0.30000000000000004 knows to treat the value with skepticism. RoughNums also cannot be compared directly for equality; they can only be compared up to a given tolerance.

Python 2
print(.1 + .2)
And
float(decimal.Decimal(".1") + decimal.Decimal(".2"))
And
.1 + .2

0.3

And

0.3

And

0.30000000000000004

Python 2’s “print” statement converts 0.30000000000000004 to a string and shortens it to “0.3”. To achieve the desired floating point result, use print(repr(.1 + .2)). This was fixed in Python 3 (see below).

Python 3
print(.1 + .2)
And
.1 + .2

0.30000000000000004

And

0.30000000000000004

Python (both 2 and 3) supports decimal arithmetic with the decimal module, and true rational numbers with the fractions module.

R
print(.1+.2)
And
print(.1+.2, digits=18)

0.3

And

0.30000000000000004

Racket (PLT Scheme)
(+ .1 .2)
And
(+ 1/10 2/10)

0.30000000000000004

And

3/10

Ruby
puts 0.1 + 0.2
And
puts 1/10r + 2/10r

0.30000000000000004

And

3/10

Ruby supports rational numbers in syntax with version 2.1 and newer directly. For older versions use Rational.
Ruby also has a library specifically for decimals: BigDecimal.

Rust
extern crate num;
use num::rational::Ratio;
fn main() {
    println!("{}", 0.1 + 0.2);
    println!("1/10 + 2/10 = {}", Ratio::new(1, 10) + Ratio::new(2, 10));
}

0.30000000000000004 1/10 + 2/10 = 3/10

Rust has rational number support from the num crate.

scala
scala -e 'println(0.1 + 0.2)'
And
scala -e 'println(0.1F + 0.2F)'
And
scala -e 'println(BigDecimal("0.1") + BigDecimal("0.2"))'

0.30000000000000004

And

0.3

And

0.3

Smalltalk
0.1 + 0.2.

0.30000000000000004

Swift
0.1 + 0.2
And
NSString(format: "%.17f", 0.1 + 0.2)

0.3

And

0.30000000000000004

Turbo Pascal 7.0
writeln(0.1 + 0.2);

3.0000000000E-01

Vala
static int main(string[] args) {
  stdout.printf("%.17f\n", 0.1 + 0.2);
  return 0;
}

0.30000000000000004

zsh
echo "$((.1+.2))"

0.30000000000000004

I am Erik Wiffin. You can contact me at: erik.wiffin.com or erik.wiffin@gmail.com.

This project is on github. If you think this page could be improved, send me a pull request.