f32 单精度浮点
什么是 f32
f32 是 Rust 的 32 位单精度浮点数类型,遵循 IEEE 754 标准。它占用 4 个字节,能表示带小数点的数字,包括正数、负数、零、正无穷、负无穷和 NaN(非数字)。
f32 提供大约 6-7 位有效十进制数字的精度。也就是说,超过 7 位有效数字后就会出现精度丢失。如果你需要更高的精度,应该用 f64。
rust
fn main() {
// f32 需要显式标注类型,因为浮点数默认推断为 f64
let x: f32 = 3.14;
let y = 2.5f32; // 用类型后缀指定为 f32
let z: f32 = -0.001;
println!("x = {}, y = {}, z = {}", x, y, z);
// f32 的表示范围
println!("最小正数:{}", f32::MIN_POSITIVE); // 约 1.17549435e-38
println!("最大值:{}", f32::MAX); // 约 3.4028235e38
println!("最小值:{}", f32::MIN); // 约 -3.4028235e38
}基本运算
rust
fn main() {
let a: f32 = 10.5;
let b: f32 = 3.2;
// 四则运算
println!("{} + {} = {}", a, b, a + b); // 13.7
println!("{} - {} = {}", a, b, a - b); // 7.3
println!("{} * {} = {}", a, b, a * b); // 33.6
println!("{} / {} = {}", a, b, a / b); // 3.28125
println!("{} % {} = {}", a, b, a % b); // 0.9000001(注意精度)
// 浮点除以 0 不会 panic,而是返回无穷大
let inf = 1.0f32 / 0.0;
println!("1.0 / 0.0 = {}", inf); // inf
println!("-1.0 / 0.0 = {}", -1.0f32 / 0.0); // -inf
// 0 除以 0 返回 NaN
let nan = 0.0f32 / 0.0;
println!("0.0 / 0.0 = {}", nan); // NaN
}常用数学方法
rust
fn main() {
let x: f32 = 2.7;
// 取整
println!("floor(2.7) = {}", x.floor()); // 2.0(向下取整)
println!("ceil(2.7) = {}", x.ceil()); // 3.0(向上取整)
println!("round(2.7) = {}", x.round()); // 3.0(四舍五入)
println!("trunc(2.7) = {}", x.trunc()); // 2.0(截断小数部分)
// 绝对值
let neg: f32 = -5.3;
println!("abs(-5.3) = {}", neg.abs()); // 5.3
// 幂和开方
println!("2.0^3 = {}", 2.0f32.powf(3.0)); // 8.0
println!("2.0^3 = {}", 2.0f32.powi(3)); // 8.0(整数幂,更快)
println!("sqrt(9.0) = {}", 9.0f32.sqrt()); // 3.0
println!("cbrt(27.0) = {}", 27.0f32.cbrt()); // 3.0(立方根)
// 三角函数
let pi: f32 = std::f32::consts::PI;
println!("sin(PI/2) = {}", (pi / 2.0).sin()); // 1.0
println!("cos(0) = {}", 0.0f32.cos()); // 1.0
// 对数和指数
println!("ln(e) = {}", std::f32::consts::E.ln()); // 1.0
println!("log2(8) = {}", 8.0f32.log2()); // 3.0
println!("log10(1000) = {}", 1000.0f32.log10()); // 3.0
// 最大值和最小值
println!("max(3.0, 5.0) = {}", 3.0f32.max(5.0)); // 5.0
println!("min(3.0, 5.0) = {}", 3.0f32.min(5.0)); // 3.0
// 限制在范围内
println!("clamp(15.0, 0.0, 10.0) = {}", 15.0f32.clamp(0.0, 10.0)); // 10.0
}特殊值
rust
fn main() {
// 正无穷和负无穷
let pos_inf = f32::INFINITY;
let neg_inf = f32::NEG_INFINITY;
println!("正无穷:{}", pos_inf);
println!("负无穷:{}", neg_inf);
// NaN(Not a Number)
let nan = f32::NAN;
println!("NaN: {}", nan);
// NaN 的特殊性质:NaN 不等于任何值,包括自己
println!("NaN == NaN: {}", nan == nan); // false
println!("NaN != NaN: {}", nan != nan); // true
// 检测特殊值
println!("is_nan: {}", nan.is_nan()); // true
println!("is_infinite: {}", pos_inf.is_infinite()); // true
println!("is_finite: {}", 3.14f32.is_finite()); // true
println!("is_normal: {}", 3.14f32.is_normal()); // true
println!("is_normal(0.0): {}", 0.0f32.is_normal()); // false(0 不是 normal)
}精度问题
rust
fn main() {
// f32 的精度有限,某些十进制小数无法精确表示
let x: f32 = 0.1;
let y: f32 = 0.2;
let sum = x + y;
println!("0.1 + 0.2 = {:.20}", sum); // 0.30000001192092895508(不是精确的 0.3)
// 所以不要用 == 直接比较浮点数
println!("0.1 + 0.2 == 0.3: {}", sum == 0.3); // false
// 正确的比较方式:检查差值是否在一个很小的范围内
let epsilon: f32 = 1e-6;
let is_close = (sum - 0.3).abs() < epsilon;
println!("近似相等:{}", is_close); // true
// f32 的有效精度大约 7 位十进制数字
let precise: f32 = 1234567.0;
let imprecise: f32 = 12345678.0;
println!("1234567.0 as f32 = {}", precise); // 精确
println!("12345678.0 as f32 = {}", imprecise); // 可能有精度丢失
}基本示例
计算二维空间中两点之间的距离:
rust
// 表示二维平面上的点
struct Point {
x: f32,
y: f32,
}
impl Point {
// 计算到另一个点的距离
fn distance_to(&self, other: &Point) -> f32 {
let dx = self.x - other.x;
let dy = self.y - other.y;
// hypot 方法比手动 sqrt(dx*dx + dy*dy) 更精确,不容易溢出
dx.hypot(dy)
}
}
fn main() {
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 3.0, y: 4.0 };
let dist = p1.distance_to(&p2);
println!("({}, {}) 到 ({}, {}) 的距离:{}", p1.x, p1.y, p2.x, p2.y, dist);
// 输出 5.0(经典的 3-4-5 直角三角形)
}常见问题
问题一:什么时候用 f32,什么时候用 f64?
| 选择 | 适用场景 | 理由 |
|---|---|---|
f64 | 大多数场景(默认) | 精度更高(15-16 位),现代 CPU 处理 f64 和 f32 一样快 |
f32 | 图形编程、游戏开发 | GPU 更擅长处理 f32,节省显存 |
f32 | 大量数据存储 | 内存占用少一半 |
f32 | 和 C 的 float 交互 | C 的 float 对应 f32 |
问题二:为什么浮点数不能做 HashMap 的 key?
因为 f32 和 f64 没有实现 Eq 和 Hash trait。原因是 NaN != NaN,这违反了 Eq 的自反性要求。如果确实需要浮点数做 key,可以用 ordered_float 这个第三方 crate。
问题三:浮点数溢出会怎样?
不会 panic。超过最大值变成 inf(正无穷),低于最小负数变成 -inf。inf 参与运算会传播:inf + 1.0 还是 inf。
问题四:f32 和 i32 之间怎么转换?
rust
fn main() {
let f: f32 = 3.99;
let i: i32 = f as i32; // 截断小数部分,得到 3(不是四舍五入)
println!("3.99 as i32 = {}", i);
let n: i32 = 42;
let f: f32 = n as f32; // 整数转浮点,可能丢失精度(大整数时)
println!("42 as f32 = {}", f);
}适用场景
- 图形和游戏开发:顶点坐标、颜色值、纹理坐标等,GPU 原生支持 f32
- 音频处理:采样值通常用 f32 表示
- 机器学习推理:模型权重在推理阶段常用 f32(甚至更低精度)
- 传感器数据:温度、湿度等物理量的精度要求不高
- 和 C 代码交互:C 的
float类型对应 Rust 的f32 - 大规模数据存储:相比 f64 节省一半内存
注意事项
- 浮点数字面量默认类型是
f64,要用f32需要标注或用后缀f32 - 不要用
==直接比较两个浮点数是否相等,应该检查差值是否小于一个很小的阈值 - NaN 不等于任何值包括自己,判断是否是 NaN 用
is_nan()方法 f32和整数类型不能直接运算,需要用as显式转换as转换浮点数到整数时是截断而不是四舍五入,如果要四舍五入先调用.round()- 浮点数除以 0 不会 panic,而是返回
inf或NaN - 不要用
f32表示金额,累积的精度误差会导致金额不对,用整数(以"分"为单位)更可靠
总结
f32 是 32 位单精度浮点数,提供约 6-7 位有效数字精度,适用于对精度要求不高但对内存占用敏感的场景,比如图形编程和大规模数据处理。它支持完整的数学运算(三角函数、对数、幂等)和特殊值(inf、NaN)。使用 f32 时最需要注意的是精度问题——不要用 == 比较浮点数,不要用它存储金额。在大多数通用计算场景中,优先选择精度更高的 f64。