`f64::abs` în Rust

Valoarea absolută a unui număr zecimal: elimină semnul minus.

Sintaxă

fn abs(self) -> f64

Ce face `f64::abs`

x.abs() returnează x fără semn: (-3.5).abs() == 3.5. Spre deosebire de întregi, nu poate da depășire. NaN.abs() rămâne NaN, iar -0.0 devine 0.0.

Cea mai frecventă folosire: compararea a două numere zecimale cu o toleranță, (a - b).abs() < 1e-9, și calculul erorilor sau diferențelor indiferent de direcție.

Ce returnează

f64.

Exemple

Exemplul 1: Abatere față de țintă

fn main() {
    let tinta = 100.0_f64;
    let masuratori: [f64; 4] = [98.5, 101.2, 100.0, 96.8];
    for m in masuratori {
        let abatere = (m - tinta).abs();
        let ok = abatere <= 2.0;
        println!("{m:6.1} -> abatere {abatere:.1}, în toleranță: {ok}");
    }
    let maxima = masuratori.iter().map(|m| (m - tinta).abs()).fold(0.0, f64::max);
    println!("abaterea maximă: {maxima:.1}");
}

Rezultat

  98.5 -> abatere 1.5, în toleranță: true
 101.2 -> abatere 1.2, în toleranță: true
 100.0 -> abatere 0.0, în toleranță: true
  96.8 -> abatere 3.2, în toleranță: false
abaterea maximă: 3.2

Exemplul 2: Comparare cu toleranță

fn aproape_egal(a: f64, b: f64) -> bool {
    (a - b).abs() <= 1e-9 * a.abs().max(b.abs()).max(1.0)
}

fn main() {
    let x = 0.1 + 0.2;
    println!("{x} == 0.3: {}", x == 0.3);
    println!("aproape_egal: {}", aproape_egal(x, 0.3));
    println!("aproape_egal(1e20, 1e20 + 1e5): {}", aproape_egal(1e20, 1e20 + 1e5));
    println!("(-0.0).abs() = {}", (-0.0_f64).abs());
}