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 的对比
| 对比项 | f32 | f64 |
|---|---|---|
| 位数 | 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和Hashf64不能排序用标准的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 都是默认且正确的选择。