f64 双精度浮点 ​

什么是 f64 ​

f64 是 Rust 的 64 位双精度浮点数类型,遵循 IEEE 754 标准。它占用 8 个字节,提供大约 15-16 位有效十进制数字的精度,是 Rust 中浮点数字面量的默认类型。当你写 let x = 3.14; 时,x 的类型就是 f64。

在现代 64 位 CPU 上,f64 的运算速度和 f32 几乎一样快,所以除非有特殊原因(比如 GPU 编程、内存敏感),否则都应该优先使用 f64。

rust
fn main() {
    // 浮点数字面量默认就是 f64,不需要额外标注
    let pi = 3.141592653589793;
    let e = 2.718281828459045;
    let negative = -273.15;

    println!("pi = {}", pi);
    println!("e = {}", e);
    println!("绝对零度 = {} 摄氏度", negative);

    // f64 的范围和精度
    println!("最大值:{}", f64::MAX);          // 约 1.7976931348623157e308
    println!("最小正数:{}", f64::MIN_POSITIVE); // 约 2.2250738585072014e-308
    println!("精度(epsilon):{}", f64::EPSILON); // 约 2.220446049250313e-16
}

f64 与 f32 的对比 ​

对比项f32f64
位数32 位(4 字节)64 位(8 字节)
有效精度约 6-7 位十进制约 15-16 位十进制
最大值约 3.4 x 10^38约 1.8 x 10^308
最小正数约 1.2 x 10^-38约 2.2 x 10^-308
默认类型否是(浮点字面量默认)
CPU 性能(64位系统)和 f64 差不多原生速度
GPU 性能通常更快通常更慢
适用场景图形、大量数据通用计算(推荐默认)
rust
fn main() {
    // f32 精度不够的例子
    let f32_val: f32 = 1.0000001;
    let f64_val: f64 = 1.0000001;

    println!("f32: {:.10}", f32_val);  // 1.0000001192(已经不精确了)
    println!("f64: {:.10}", f64_val);  // 1.0000001000(精确)

    // 累积误差对比
    let mut sum_f32: f32 = 0.0;
    let mut sum_f64: f64 = 0.0;
    for _ in 0..1_000_000 {
        sum_f32 += 0.1f32;
        sum_f64 += 0.1f64;
    }
    println!("f32 累加 100万次 0.1 = {}", sum_f32);  // 误差较大
    println!("f64 累加 100万次 0.1 = {}", sum_f64);  // 误差较小
}

数学常量 ​

Rust 标准库提供了常用的数学常量:

rust
fn main() {
    // std::f64::consts 模块中的常量
    use std::f64::consts;

    println!("PI = {}", consts::PI);               // 3.141592653589793
    println!("E = {}", consts::E);                 // 2.718281828459045
    println!("SQRT_2 = {}", consts::SQRT_2);       // 1.4142135623730951
    println!("LN_2 = {}", consts::LN_2);           // 0.6931471805599453
    println!("LN_10 = {}", consts::LN_10);         // 2.302585092994046
    println!("TAU = {}", consts::TAU);             // 6.283185307179586(2*PI)
    println!("FRAC_PI_2 = {}", consts::FRAC_PI_2); // PI/2
    println!("FRAC_1_SQRT_2 = {}", consts::FRAC_1_SQRT_2); // 1/sqrt(2)
}

格式化输出 ​

rust
fn main() {
    let val = 3.141592653589793_f64;

    // 控制小数位数
    println!("默认:{}", val);            // 3.141592653589793
    println!("2 位小数:{:.2}", val);     // 3.14
    println!("5 位小数:{:.5}", val);     // 3.14159
    println!("10 位小数:{:.10}", val);   // 3.1415926536

    // 科学计数法
    let big = 1234567890.123;
    println!("科学计数法(小写):{:e}", big);   // 1.234567890123e9
    println!("科学计数法(大写):{:E}", big);   // 1.234567890123E9

    // 指定宽度和对齐
    println!("右对齐,宽度10:{:>10.2}", val);  // "      3.14"
    println!("左对齐,宽度10:{:<10.2}", val);  // "3.14      "
    println!("居中,宽度10:{:^10.2}", val);    // "   3.14   "

    // 用零填充
    println!("补零:{:010.2}", val);             // "0000003.14"

    // 始终显示正号
    println!("带正号:{:+.2}", val);             // "+3.14"
    println!("带负号:{:+.2}", -val);            // "-3.14"
}

基本示例 ​

温度转换计算器:

rust
// 摄氏度转华氏度
fn celsius_to_fahrenheit(c: f64) -> f64 {
    c * 9.0 / 5.0 + 32.0
}

// 华氏度转摄氏度
fn fahrenheit_to_celsius(f: f64) -> f64 {
    (f - 32.0) * 5.0 / 9.0
}

// 摄氏度转开尔文
fn celsius_to_kelvin(c: f64) -> f64 {
    c + 273.15
}

fn main() {
    let temperatures = [0.0, 20.0, 37.0, 100.0, -40.0];

    println!("{:<12} {:>12} {:>12}", "摄氏度", "华氏度", "开尔文");
    println!("{}", "-".repeat(38));

    for &c in &temperatures {
        let f = celsius_to_fahrenheit(c);
        let k = celsius_to_kelvin(c);
        println!("{:<12.1} {:>12.1} {:>12.2}", c, f, k);
    }

    // 验证 -40 度是摄氏和华氏的交叉点
    let cross = -40.0;
    println!("\n验证:{}°C = {}°F",
        cross, celsius_to_fahrenheit(cross));
}

常见问题 ​

问题一:为什么 0.1 + 0.2 != 0.3?

这不是 Rust 的 bug,是所有使用 IEEE 754 浮点数的语言都有的问题。0.1 在二进制中是无限循环小数,无法精确存储,只能存一个近似值。两个近似值相加的结果和 0.3 的近似值略有不同。

rust
fn main() {
    let a: f64 = 0.1 + 0.2;
    let b: f64 = 0.3;
    println!("0.1 + 0.2 = {:.20}", a);  // 0.30000000000000004441
    println!("0.3       = {:.20}", b);   // 0.29999999999999998890

    // 正确的比较方式
    let close_enough = (a - b).abs() < f64::EPSILON * 10.0;
    println!("近似相等:{}", close_enough);
}

问题二:f64 和整数之间怎么转换?

rust
fn main() {
    // 整数转 f64:大多数情况安全
    let n: i32 = 42;
    let f: f64 = n as f64;  // 精确
    // 但超大整数可能丢精度
    let big: i64 = 9_007_199_254_740_993;
    let f_big: f64 = big as f64;
    println!("原始:{}", big);
    println!("转 f64 后:{}", f_big);  // 可能不精确

    // f64 转整数:截断小数部分
    let pi: f64 = 3.99;
    println!("截断:{}", pi as i32);    // 3
    println!("四舍五入:{}", pi.round() as i32);  // 4
    println!("向上:{}", pi.ceil() as i32);       // 4
    println!("向下:{}", pi.floor() as i32);      // 3
}

问题三:NaN 和 Infinity 参与运算会怎样?

NaN 具有"传染性"——任何涉及 NaN 的运算结果都是 NaN。Infinity 在大多数运算中会保持或传播。

rust
fn main() {
    let nan = f64::NAN;
    println!("NaN + 1.0 = {}", nan + 1.0);   // NaN
    println!("NaN * 0.0 = {}", nan * 0.0);   // NaN

    let inf = f64::INFINITY;
    println!("inf + 1.0 = {}", inf + 1.0);   // inf
    println!("inf * -1 = {}", inf * -1.0);    // -inf
    println!("inf - inf = {}", inf - inf);     // NaN
    println!("1.0 / inf = {}", 1.0 / inf);   // 0
}

问题四:f64 能精确表示所有整数吗?

不能。f64 能精确表示的最大整数是 2^53(9,007,199,254,740,992)。超过这个范围的整数转成 f64 会丢失精度。在这个范围内的整数是可以精确表示的。

适用场景 ​

  • 通用科学计算:物理模拟、统计分析、数值方法
  • 金融计算中的中间步骤:最终结果应该用整数(分为单位),但中间计算可以用 f64
  • 地理坐标:经纬度需要较高精度
  • 机器学习训练:模型训练阶段通常使用 f64 以保证数值稳定性
  • 天文学和物理学:大范围和高精度的数值
  • 日常数学运算:除非有特殊理由,浮点计算都用 f64

注意事项 ​

  • 浮点数默认类型是 f64,不需要额外标注
  • 不要用 == 比较浮点数,用差值的绝对值和阈值比较
  • f64 不能做 HashMap 的 key,因为没有实现 Eq 和 Hash
  • f64 不能排序用标准的 sort(),需要用 sort_by() 配合 partial_cmp 或 total_cmp
  • 浮点运算不会 panic(除以零返回 inf/NaN),要自己检查结果是否合理
  • 不要用浮点数表示金额,累积误差会导致实际金额不对
  • f64 as i32 是截断不是四舍五入,注意转换前用 round() / ceil() / floor()

总结 ​

f64 是 Rust 的默认浮点类型,提供 15-16 位有效数字精度,在现代 CPU 上性能与 f32 相当。浮点数不能精确表示所有十进制小数,因此不能用 == 直接比较,不能用来表示金额。Rust 标准库为 f64 提供了丰富的数学方法(三角函数、对数、幂、取整等)和数学常量(PI、E 等)。在绝大多数需要小数的场景中,f64 都是默认且正确的选择。