文章討論了計算機中的浮點運算問題，給出了各種不同語言的浮點輸出。
浮點數運算
你使用的語言並不爛，它能夠做浮點數運算。計算機天生只能儲存整數，因此它需要某種方法來表示小數。這種表示方式會帶來某種程度的誤差。這就是為什麼往往 0.1 + 0.2 不等於 0.3。
為什麼會這樣？
實際上很簡單。對於十進位制數值系統（就是我們現實中使用的），它只能表示以進位制數的質因子為分母的分數。10 的質因子有 2 和 5。因此 1/2、1/4、1/5、1/8和 1/10 都可以精確表示，因為這些分母只使用了10的質因子。相反，1/3、1/6 和 1/7 都是迴圈小數，因為它們的分母使用了質因子 3 或者 7。二進位制下（進位制數為2），只有一個質因子，即2。因此你只能精確表示分母質因子是2的分數。二進位制中，1/2、1/4 和 1/8 都可以被精確表示。但是，1/5 或者 1/10 就變成了迴圈小數。所以，在十進位制中能夠精確表示的 0.1 與 0.2（1/10 與 1/5），到了計算機所使用的二進位制數值系統中，就變成了迴圈小數。當你對這些迴圈小數進行數學運算時，並將二進位制資料轉換成人類可讀的十進位制資料時，會對小數尾部進行截斷處理。
下面是在不同的語言中，執行 0 .1 + 0.2 的輸出結果：
| 語言 | 程式碼 | 結果 |
| C | #include<stdio.h>int main(int argc, char* argv) {printf(“%.17fn”, .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 |
| 注1：PHP 將 0.30000000000000004 格式化成字串時，會把它縮短成 “0.3”。為了得到需要的浮點數結果，在 ini檔案中調整精度設定：iniset(“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 |
| 注2：Ruby 2.1及以後版本在語法上支援有理數。對於老版本，請使用 Rational。Ruby還有一個專門處理小數的庫： BigDecimal。 |
||
| Python 2 | print(.1 + .2)
float(decimal.Decimal(“.1”) + decimal.Decimal(“.2”)) .1 + .2 |
0.3
0.3 0.30000000000000004 |
| 注3：Python 2 中的 “print” 語句將 0.30000000000000004 轉成一個字串，並縮短成 “0.3”。為了達到需要的浮點數結果，使用 print(repr(.1 + .2))。在 Python 3中這是內建設定（見下面例子）。 | ||
| Python 3 | print(.1 + .2)
.1 + .2 |
0.30000000000000004
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);System.out.println(.1F + .2F); | 0.30000000000000004
0.3 |
| Julia | .1 + .2 | 0.30000000000000004 |
| 注4：Julia 內建 支援有理數 ，並且還有一個內建的資料型別BigFloat，它支援任意精度 。要得到正確的運算結果，使用 1//10 + 2//10 會返回3//10。 | ||
| Clojure | (+ 0.1 0.2) | 0.30000000000000004 |
| 注5：Clojure 支援任意精度的資料。 (+ 0.1M 0.2M) 返回 0.3M，而 (+ 1/10 2/10) 返回 3/10。 | ||
| C# | Console.WriteLine(“{0:R}”, .1 + .2); | 0.30000000000000004 |
| GHC (Haskell) | 0.1 + 0.2 | 0.30000000000000004 |
| 注6：Haskell 支援有理數。要得到正確的運算結果，使用 (1 % 10) + (2 % 10) 返回 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 |
| 注7：Rust 中，使用 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(“%.54fn”, .1 + .2) } | 0.3 0.30000000000000004 0.299999999999999988897769753748434595763683319091796875 |
| 注8：Go語言的數字常數有任意精度。 | ||
| 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 |
| 注9：Perl 6 與 Perl 5 不同，預設使用有理數。因此 .1 被儲存成類似這樣 { 分子 => 1, 分母 => 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 | 0.3 |
| 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 |
更多參考資料：| wikipedia | IEEE 754 | Stack Overflow
我是Erik Wiffin。聯絡方式： erik.wiffin.com 或者 erik.wiffin@gmail.com。
這個專案已經放在 github。如果你覺得這個頁面需要改進，發訊息給我。