• Floating Point Math

    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
", .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 
    (+ 0.1d0 0.2d0)
    And 
    (- 1.2 1.0)

    0.3

    And

    3/10

    And

    0.30000000000000004d0

    And

    0.20000005

    CL’s spec doesn’t actually even require radix 2 floats (let alone specifically 32-bit singles and 64-bit doubles), but the high-performance implementations all seem to use IEEE floats with the usual sizes. This was tested on SBCL and ECL in particular.
    C++ 
    #include <iomanip>
std::cout << std::setprecision(17) << 0.1 + 0.2

    0.30000000000000004
    Crystal 
    puts 0.1 + 0.2
    And 
    puts 0.1_f32 + 0.2_f32

    0.30000000000000004

    And

    0.3
    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
    elvish 
    + .1 .2

    0.30000000000000004

    elvish uses Go’s double for numerical operations.
    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, 0.1 + 0.2 :: Rational returns 3 % 10, which is exactly 0.3.
    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
", .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.2)

    0.3

    And

    0.30000000000000004
    MySQL 
    SELECT .1 + .2;

    0.3
    Nim 
    echo(0.1 + 0.2)

    0.3
    Objective-C 
    #import <Foundation/Foundation.h>
int main(int argc, const char * argv[]) {
  @autoreleasepool {
    NSLog(@"%.17f
", .1+.2);
  }
  return 0;
}

    0.30000000000000004
    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 (0.1+0.2).base(10, 17)'
    And 
    perl6 -e 'say 1/10+2/10'
    And 
    perl6 -e 'say (0.1.Num + 0.2.Num).base(10, 17)'

    0.3

    And

    0.3

    And

    0.3

    And

    0.30000000000000004

    Perl 6, unlike Perl 5, uses rationals by default, so .1 is stored something like { numerator => 1, denominator => 10 }. To actually trigger the behavior, you must force the numbers to be of type Num (double in C terms) and use the base function instead of the sprintf or fmt functions (since those functions have a bug that limits the precision of the output).
    PHP 
    echo .1 + .2; 
var_dump(.1 + .2);

    0.3 float(0.30000000000000004441)

    PHP echo converts 0.30000000000000004441 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/6016d743c4c124a1c04fc12accf7ef17
    And 
    [println (+ (/ 1 10) (/ 2 10))]

    (/ 3 10)

    You must load file “frac.min.l”.
    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.30000000000000004knows 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 
    .1 + .2
    And 
    float(decimal.Decimal(".1") + decimal.Decimal(".2"))
    And 
    float(fractions.Fraction('0.1') + fractions.Fraction('0.2'))

    0.3

    And

    0.30000000000000004

    And

    0.3

    And

    0.3

    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
    And 
    float(decimal.Decimal('.1') + decimal.Decimal('.2'))
    And 
    float(fractions.Fraction('0.1') + fractions.Fraction('0.2'))

    0.30000000000000004

    And

    0.30000000000000004

    And

    0.3

    And

    0.3

    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

    And

    1/10 + 2/10 = 3/10

    Rust has rational number support from the num crate.
    SageMath 
    .1 + .2
    And 
    RDF(.1) + RDF(.2)
    And 
    RBF('.1') + RBF('.2')
    And 
    QQ('1/10') + QQ('2/10')

    0.3

    And

    0.30000000000000004

    And

    [“0.300000000000000 +/- 1.64e-16”]

    And

    3/10

    SageMath supports various fields for arithmetic: Arbitrary Precision Real Numbers, RealDoubleField, Ball Arithmetic, Rational Numbers, etc.
    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
    TCL 
    puts [expr .1 + .2]

    0.30000000000000004
    Turbo Pascal 7.0 
    writeln(0.1 + 0.2);

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

    0.30000000000000004
    Visual Basic 6 
    a# = 0.1 + 0.2: b# = 0.3
Debug.Print Format(a - b, "0." & String(16, "0"))
Debug.Print a = b

    0.0000000000000001
    False

    Appending the identifier type character # to any identifier forces it to Double.
    WebAssembly (WAST) 
    (func $add_f32 (result f32)
    f32.const 0.1
    f32.const 0.2
    f32.add)
(export "add_f32" (func $add_f32))
    And 
    (func $add_f64 (result f64)
    f64.const 0.1
    f64.const 0.2
    f64.add)
(export "add_f64" (func $add_f64))

    0.30000001192092896

    And

    0.30000000000000004

    https://webassembly.studio/?f=r739k6d6q4t
    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.
  • 相关阅读:
    .NET-记一次架构优化实战与方案-梳理篇
    .net core实践系列之SSO-跨域实现
    Vue
    C# WPF
    开源框架
    开源框架
    开源框架
    开源框架
    WCF
    WCF
  • 原文地址：https://www.cnblogs.com/zhuyeshen/p/11005215.html
Copyright © 2020-2023  润新知