`f64` în Rust

Tipul implicit pentru numere cu zecimale: virgulă mobilă pe 64 de biți (precizie dublă, IEEE 754).

Sintaxă

let x: f64 = 3.14;
let y = 2.5e-3;

f64::MAX, f64::MIN_POSITIVE, f64::EPSILON
f64::INFINITY, f64::NEG_INFINITY, f64::NAN
std::f64::consts::PI

Ce face `f64`

f64 reține numere cu zecimale cu aproximativ 15-17 cifre semnificative. Este tipul ales automat pentru let x = 2.5;. Există și f32, cu precizie mai mică. Literalii folosesc punctul zecimal (3.14), iar 2.5e-3 înseamnă 0.0025.

Multe valori zecimale (0.1, 0.2) nu pot fi reprezentate exact în binar, deci apar mici erori: 0.1 + 0.2 nu este exact 0.3. De aceea numerele f64 se compară cu o toleranță, iar sumele de bani se țin de obicei în întregi (bani, cenți).

Împărțirea la zero nu dă panică: rezultatul este inf, -inf sau NaN (not a number). Conversia x as i32 taie zecimalele și se oprește la limitele tipului; NaN devine 0.

Ce returnează

Este un tip, nu o funcție.

Exemple

Exemplul 1: Precizie și comparare

fn main() {
    let suma: f64 = 0.1 + 0.2;
    println!("0.1 + 0.2 = {suma}");
    println!("egal cu 0.3: {}", suma == 0.3);
    println!("aproape egal: {}", (suma - 0.3).abs() < 1e-9);
    println!("cu 2 zecimale: {suma:.2}");
    println!("EPSILON = {:e}", f64::EPSILON);
    println!("MAX = {:e}", f64::MAX);
}

Rezultat

0.1 + 0.2 = 0.30000000000000004
egal cu 0.3: false
aproape egal: true
cu 2 zecimale: 0.30
EPSILON = 2.220446049250313e-16
MAX = 1.7976931348623157e308

Exemplul 2: Infinit, NaN și conversii

fn main() {
    let zero = 0.0_f64;
    println!("1 / 0 = {}", 1.0 / zero);
    println!("-1 / 0 = {}", -1.0 / zero);
    println!("0 / 0 = {}", zero / zero);

    println!("9.99 as i32 = {}", 9.99_f64 as i32);
    println!("-9.99 as i32 = {}", -9.99_f64 as i32);
    println!("NaN as i32 = {}", f64::NAN as i32);
    println!("1e20 as i32 = {}", 1e20_f64 as i32);
    println!("{:?}", "3,5".parse::<f64>().is_err());
}