【Rust 课外知识】0.1+0.2为什么不等于0.3(下)

简介: 【Rust 课外知识】0.1+0.2为什么不等于0.3(下)

0x00 开篇


上一篇文章主要介绍了一些基本概念,既然已经了解了基本概念了,那么这篇文章也就很容易理解了。


0x02 无限浮点数


在十进制中存在无限小数,π 是一个无限不循环小数,还有 1 ÷ 3 = 0.333333...这是一个无限循环小数 。那其实在二进制中也存在同样的问题。例如:十进制的0.1,按照上一篇文章所说的,转化为二进制过程如下:

0.1 => 0.1 × 2 = 0.2
0.2 => 0.2 × 2 = 0.4
0.4 => 0.4 × 2 = 0.8
0.8 => 0.8 × 2 = 1.6
1.6 => 0.6 × 2 = 1.2
0.2 => 0.2 × 2 = 0.4
0.4 => 0.4 × 2 = 0.8
......此处省略

那最终结果就是0.00011001100..... 由此可见十进制的有限小数0.1转化为二进制后会变成无限小数,精度会丢失。同理十进制0.2表示为二进制则是0.00110011001.....


0x03 转换为指数


普通转换


其实文章读到这里,大家也应该有点儿理解是什么原因了。以64位浮点数运算为例。

十进制0.1的二进制指数:

1.1001 1001 1001 1001 1001 1001 1001 10001 1001
1001 1001 1001 1001... × 2 ^ -100

十进制0.2的二进制指数:

1.1001 1001 1001 1001 1001 1001 1001 10001 1001
1001 1001 1001 1001... × 2 ^ -11


按照IEEE754标准转换


上篇文章提到IEEE754标准,只有52位数,如果是一个无限小数,则需按照“四舍五入”标准舍弃。

十进制0.1的二进制指数(IEEE754):

1.1001 1001 1001 1001 1001 1001 1001 10001 1001
1001 1001 1001 1010 (第53位是1,舍弃时需要进位) × 2 ^ -100

十进制0.2的二进制指数(IEEE754):

1.1001 1001 1001 1001 1001 1001 1001 10001 1001
1001 1001 1001 1010 (第53位是1,舍弃时需要进位) × 2 ^ -11

为了看得更加清楚,可以看下面的图片。


0a2653c851af460fa595bd959398a8f1.png


0x04 计算


由于指数位不同,所以不能直接进行比较。首先就是要移位,我们对0.1进行移位。


2d65d23f6d4748949b924e4057485923.png


然后再求和计算得出结果。


6de278e6d6694ce5bb08e7e842b7e74b.png


最终得出0.3的二进制为

0.010 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0110 0111

将上面的结果转化为十进制:

二进制转为十进制要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右。

= 0 × 2^-1 + 1 × 2^-2 + ... + 1 × 2^-52
= 0.30000000000000004 ?


0x05 验证结果


用Rust来计算下结果并验证。源码在第7节获取。

PS:以下代码使用NIGHTLY版本构建。可以使用Rust在线编译器去编译(https://play.rust-lang.org/)。


8ec4f2997fb246878c34ecd6d122b7c6.png


结果说明一切!


0x06 小结


其实,不仅仅只有0.1 + 0.2 会出现这种结果,像类似的0.1 + 0.7 = 0.7999999999999999等等,只要十进制转化为二进制是无限的,就会出现这种结果。其实这种现象也不仅仅在Rust存在,在常见的Java,C,JavaScript等等都会存在以上现象,这也是一个老生常谈的话题了。


0x07 源码


#![feature(core_intrinsics)]
use std::intrinsics::powf64;
fn main() {
    let a = 0.1;
    let b = 0.2;
    println!("{} + {} = {}", a, b, a + b);
    calc();
}
fn calc() {
    unsafe {
        let s = "0100110011001100110011001100110011001100110011001100111";
        let mut index = -1_f64;
        let mut sum = 0_f64;
        for i in s.chars() {
            let temp = char::to_digit(i, 10).unwrap() as f64;
            let k = powf64(2_f64, index);
            sum += temp * k;
            index -= 1_f64;
        }
        println!("{}", sum);
    }
}

运行结果:

0.1 + 0.2 = 0.30000000000000004
0.30000000000000004
相关文章
|
Rust Java 调度
【Rust 课外知识】Rust中的三种多态性(下)——Enum + Struct
【Rust 课外知识】Rust中的三种多态性(下)——Enum + Struct
【Rust 课外知识】Rust中的三种多态性(下)——Enum + Struct
|
Rust C++
【Rust 课外知识】你还不知道的Rust10个小技巧(下)
【Rust 课外知识】你还不知道的Rust10个小技巧(下)
【Rust 课外知识】你还不知道的Rust10个小技巧(下)
|
Rust Unix Go
【Rust 课外知识】你还不知道的Rust10个小技巧(上)
【Rust 课外知识】你还不知道的Rust10个小技巧(上)
【Rust 课外知识】你还不知道的Rust10个小技巧(上)
|
机器学习/深度学习 Rust
【Rust 课外知识】0.1+0.2为什么不等于0.3(上)
【Rust 课外知识】0.1+0.2为什么不等于0.3(上)
【Rust 课外知识】0.1+0.2为什么不等于0.3(上)
|
缓存 Rust Java
【Rust 课外知识】Rust中的三种多态性(中)——Trait的两种方式
【Rust 课外知识】Rust中的三种多态性(中)——Trait的两种方式
|
存储 Rust Java
【Rust 课外知识】Rust中的三种多态性(上)——Enum和Trait
【Rust 课外知识】Rust中的三种多态性(上)——Enum和Trait
|
7天前
|
Rust 安全 Java
探索Rust语言的并发编程模型
探索Rust语言的并发编程模型
|
14天前
|
Rust 安全 区块链
探索Rust语言:系统编程的新选择
【10月更文挑战第27天】Rust语言以其安全性、性能和并发性在系统编程领域受到广泛关注。本文介绍了Rust的核心特性,如内存安全、高性能和强大的并发模型,以及开发技巧和实用工具,展示了Rust如何改变系统编程的面貌,并展望了其在WebAssembly、区块链和嵌入式系统等领域的未来应用。
|
15天前
|
Rust 安全 Java
编程语言新宠:Rust语言的特性、优势与实战入门
【10月更文挑战第27天】Rust语言以其独特的特性和优势在编程领域迅速崛起。本文介绍Rust的核心特性,如所有权系统和强大的并发处理能力,以及其性能和安全性优势。通过实战示例,如“Hello, World!”和线程编程,帮助读者快速入门Rust。
32 1
|
16天前
|
Rust 安全 编译器
编程语言新宠:Rust语言的特性、优势与实战入门
【10月更文挑战第26天】Rust语言诞生于2006年,由Mozilla公司的Graydon Hoare发起。作为一门系统编程语言,Rust专注于安全和高性能。通过所有权系统和生命周期管理,Rust在编译期就能消除内存泄漏等问题,适用于操作系统、嵌入式系统等高可靠性场景。
28 2