Rust 学习笔记：比较数值

Rust 学习笔记：比较数值

整数类型

在 Rust 中，可以用以下运算符比较数值：

>、<、==、!=、>=、<=

但是， Rust 不允许比较不同类型的值。

解决方法 1：使用 as 进行类型转换

fn main() {
    let a: i32 = 10;
    let b: u16 = 100;
    if a < (b as i32) {
        println!("{a} is less than {}", b);
    }
}

从范围小的类型转换成范围大的类型是安全的，比如 u16 -> i32。

但要注意从范围大的类型转换成范围小的类型，编译不会报错，但结果可能不对。

解决方法 2：使用 try_into() 进行类型转换

try_into() 方法：

• 导入 std::convert::TryInto trait。
• 该方法返回 Result 类型。

use std::convert::TryInto;

fn main() {
    let a: i32 = 10;
    let b: u16 = 100;
    let b = b.try_into().unwrap();
    if a < b {
        println!("{a} is less than {}", b);
    }
}

浮点类型

Rust 中的浮点类型（如 f32、f64）是基于二进制实现的，但我们通常用十进制来计算数值。

浮点类型的某些值不能很好地结合在一起。例如 f32、f64 只实现了 std::cmp::PartialEq，而其他数值类型还实现了 std::cmp::Eq。

针对浮点类型的指导方针：

• 避免测试浮点类型的相等性
• 如果结果在数学上是未定义的，这时候要小心

示例 1：

fn main() {
    assert!(0.1 + 0.2 == 0.3);
}

该程序执行会出错：

浮点数的底层表示使得 0.1 + 0.2 和 0.3 存在极其细微的差别。

示例 2：

fn main() {
    let abc: (f32, f32, f32) = (0.1, 0.2, 0.3);
    let xyz: (f64, f64, f64) = (0.1, 0.2, 0.3);

    println!("abc (f32)");
    println!("   0.1 + 0.2: {:x}", (abc.0 + abc.1).to_bits());
    println!("         0.3: {:x}", (abc.2).to_bits());
    println!();

    println!("xyz (f64)");
    println!("   0.1 + 0.2: {:x}", (xyz.0 + xyz.1).to_bits());
    println!("         0.3: {:x}", (xyz.2).to_bits());
    println!();
    
    assert!(abc.0 + abc.1 == abc.2);
    assert!(xyz.0 + xyz.1 == xyz.2);
}

程序在最后的 assert! 还是出错了：

在 f64 类型中，我们看到 0.1 + 0.2 为 3fd3333333333334，而 0.3 为 3fd3333333333333，它们并不是完全相等。

那么，我们怎么比较浮点类型呢？

一般来说，测试数学运算是否在其真实数学结果的可接受范围内更安全。这个边界通常被称为 ε。

Rust 提供了一些可容忍的误差值：f32::EPSILON 和 f64::EPSILON。

示例 3：

fn main() {
    let result: f32 = 0.1 + 0.2;
    let desired: f32 = 0.3;

    let abs_diff = (desired - result).abs();
    
    assert!(abs_diff <= f32::EPSILON);
}

程序正常执行。

示例 4：

fn main() {
    let result: f64 = 0.1 + 0.2;
    let desired: f64 = 0.3;
    
    println!("{}", desired - result);
    
    let abs_diff = (desired - result).abs();
    
    assert!(abs_diff <= f64::EPSILON);
}

程序正常执行。输出：-0.00000000000000005551115123125783。可以看出误差很小，且小于 f64::EPSILON。

Rust 编译器实际上将比较的工作交给了 CPU，浮点运算是使用芯片内的定制硬件实现的。

NAN

NAN 表示“不是一个数”，例如负数的平方根就是 NAN。

NAN 会影响其它数值：

• 几乎所有与 NAN 交互的操作都返回 NAN
• NAN 值永远不相等

相关方法：

• is_nan()：判断一个数是不是 NAN
• is_finite()：判断一个数是不是有限的

示例：

fn main() {
    let x: f32 = 1.0 / 0.0;
    assert!(x.is_finite());
}

程序出错：