`f64::is_nan` în Rust

Verifică dacă valoarea este NaN („nu e număr”), singurul mod sigur, pentru că NaN nu este egal nici cu el însuși.

Sintaxă

const fn is_nan(self) -> bool
const fn is_finite(self) -> bool
const fn is_infinite(self) -> bool

Ce face `f64::is_nan`

NaN apare din operații fără rezultat definit: 0.0 / 0.0, (-1.0).sqrt(), inf - inf. Orice calcul care îl conține dă tot NaN, iar orice comparație cu el dă false, inclusiv NaN == NaN. De aceea nu-l poți găsi cu ==; folosești x.is_nan().

is_finite() este true pentru numerele obișnuite (nici infinit, nici NaN), iar is_infinite() pentru inf și -inf. Atenție: "NaN".parse::<f64>() și "inf".parse::<f64>() reușesc, deci validarea datelor de intrare trebuie să verifice și is_finite().

Ce returnează

bool.

Exemple

Exemplul 1: De unde vine NaN și cum îl recunoști

fn main() {
    let zero = 0.0_f64;
    let valori = [zero / zero, (-1.0_f64).sqrt(), 1.0 / zero, 42.0];
    for v in valori {
        println!("{v:>4}: is_nan = {:5}, is_finite = {:5}, is_infinite = {}", v.is_nan(), v.is_finite(), v.is_infinite());
    }
    let n = f64::NAN;
    println!("NaN == NaN: {}", n == n);
}

Rezultat

 NaN: is_nan = true , is_finite = false, is_infinite = false
 NaN: is_nan = true , is_finite = false, is_infinite = false
 inf: is_nan = false, is_finite = false, is_infinite = true
  42: is_nan = false, is_finite = true , is_infinite = false
NaN == NaN: false

Exemplul 2: Validarea unui număr citit

fn citeste_pret(text: &str) -> Result<f64, String> {
    let p: f64 = text.trim().parse().map_err(|_| format!("„{text}” nu este număr"))?;
    if !p.is_finite() {
        return Err(format!("„{text}” nu este un preț valid"));
    }
    if p < 0.0 {
        return Err(String::from("prețul nu poate fi negativ"));
    }
    Ok(p)
}

fn main() {
    for t in ["24.90", "NaN", "inf", "-5", "doi"] {
        println!("{t:6} -> {:?}", citeste_pret(t));
    }
}