0.1+0.2!=0.3
2017-03-06 14:50
609 查看
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.
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.
Language | Code | Result |
C | #include<stdio.h> int main(int argc, char** argv) { printf("%.17f\n", .1+.2); return 0; } | 0.30000000000000004 |
C++ | #include <iomanip> std::cout << setprecision(17) << 0.1 + 0.2 << std.endl; | 0.30000000000000004 |
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). | ||
MySQL | SELECT .1 + .2; | 0.3 |
Postgres | SELECT select 0.1::float + 0.2::float; | 0.3 |
Delphi XE5 | writeln(0.1 + 0.2); | 3.00000000000000E-0001 |
Erlang | io:format("~w~n", [0.1 + 0.2]). | 0.30000000000000004 |
Elixir | IO.puts(0.1 + 0.2) | 0.30000000000000004 |
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. | ||
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 |
Lua | print(.1 + .2) print(string.format("%0.17f", 0.1 + 0.2)) | 0.3 0.30000000000000004 |
JavaScript | document.writeln(.1 + .2); | 0.30000000000000004 |
Java | System.out.println(.1 + .2); And System.out.println(.1F + .2F); | 0.30000000000000004 And 0.3 |
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. | ||
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. | ||
C# | Console.WriteLine("{0:R}", .1 + .2); | 0.30000000000000004 |
GHC (Haskell) | 0.1 + 0.2 | 0.30000000000000004 |
Haskell supports rational numbers. To get the math right, (1 % 10) + (2 % 10) returns 3 % 10. | ||
Hugs (Haskell) | 0.1 + 0.2 | 0.3 |
bc | 0.1 + 0.2 | 0.3 |
Nim | echo(0.1 + 0.2) | 0.3 |
Gforth | 0.1e 0.2e f+ f. | 0.3 |
dc | 0.1 0.2 + p | .3 |
Racket (PLT Scheme) | (+ .1 .2) And (+ 1/10 2/10) | 0.30000000000000004 And 3/10 |
Rust | extern crate num; use num::rational::Ratio; fn main() { println!(.1+.2); println!("1/10 + 2/10 = {}", Ratio::new(1, 10) + Ratio::new(2, 10)); } | 0.30000000000000004 3/10 |
Rust has rational number support from the num crate. | ||
Emacs Lisp | (+ .1 .2) | 0.30000000000000004 |
Turbo Pascal 7.0 | writeln(0.1 + 0.2); | 3.0000000000E-01 |
Common Lisp | * (+ .1 .2) And * (+ 1/10 2/10) | 0.3 And 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. | ||
Objective-C | 0.1 + 0.2; | 0.300000012 |
OCaml | 0.1 +. 0.2;; | float = 0.300000000000000044 |
Powershell | PS C:\>0.1 + 0.2 | 0.3 |
Prolog (SWI-Prolog) | ?- X is 0.1 + 0.2. | X = 0.30000000000000004. |
Perl 5 | perl -E 'say 0.1+0.2' perl -e 'printf q{%.17f}, 0.1+0.2' | 0.3 0.30000000000000004 |
Perl 6 | perl6 -e 'say 0.1+0.2' perl6 -e 'say sprintf(q{%.17f}, 0.1+0.2)' perl6 -e 'say 1/10+2/10' | 0.3 0.30000000000000000 0.3 |
Perl 6, unlike Perl 5, uses rationals by default, so .1 is stored something like { numerator => 1, denominator => 10 }.. | ||
R | print(.1+.2) print(.1+.2, digits=18) | 0.3 0.300000000000000044 |
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 NSString(format: "%.17f", 0.1 + 0.2) | 0.3 0.30000000000000004 |
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 |
ABAP | WRITE / CONV f( '.1' + '.2' ). And WRITE / CONV decfloat16( '.1' + '.2' ). | 3.0000000000000004E-01 And 0.3 |
相关文章推荐
- 如何解决JavaScript中0.1+0.2不等于0.3
- 0.1+0.2!=0.3, why? how to solve? -- 简议javascript的浮点运算
- 0.1 + 0.2 !== 0.3 就是要说清楚因为个啥?
- js精确计算:0.1 + 0.2 === 0.3 未必为true哦!
- 解决JavaScript中0.1+0.2不等于0.3问题
- 0.1+0.2等于0.3吗
- 揭秘 0.1 + 0.2 != 0.3(php 请自觉点用round)
- 为什么 javascript 中 0.1 + 0.2 !== 0.3 为 True
- [内存管理]管理图解v0.1 v0.2 v0.3
- 关于0.3-0.2 != 0.1 的问题
- [内存管理]管理图解v0.1 v0.2 v0.3
- 0.1+0.2==0.3?
- javascript中0.1 + 0.2 != 0.3?
- 揭秘 0.1 + 0.2 != 0.3
- javascript 二进制浮点数的问题,0.3-0.2不等于0.1
- JavaScript的设计缺陷?浮点运算:0.1 + 0.2 != 0.3
- 原来 0.1*0.2!=0.02
- Why 0.1 + 0.2 = 0.30000000000000004 in python ?
- js: 0.1+0.2
- 0.1+0.2=0.30000000000000004