Floating point 如何获取包含浮点数的迭代器的最小值或最大值？

我明白，但当我想偷懒并使用迭代器时，这对我并没有特别的帮助

是否有一种解决方法或一种简单的方法通过使用包含浮点数的迭代器来获取最小/min/min_

我知道一个人可以排序（速度很慢）或将其包装成另一种类型，并实现所需的交易（很详细），但我希望有更优雅的东西。

浮动有自己的方法和方法，可以一致地处理NaN，因此您可以折叠迭代器：

use std::f64;

fn main() {
    let x = [2.0, 1.0, -10.0, 5.0, f64::NAN];

    let min = x.iter().fold(f64::INFINITY, |a, &b| a.min(b));
    println!("{}", min);
}

打印

-10

如果需要不同的NaN处理，可以使用

PartialOrd:：partial\u cmp

。例如，如果要传播NAN，请使用以下折叠：

use std::f64;
use std::cmp::Ordering;

fn main() {
    let x = [2.0, 1.0, -10.0, 5.0, f64::NAN];

    let min = x.iter().fold(f64::INFINITY, |a, &b| {
        match PartialOrd::partial_cmp(&a, &b) {
            None => f64::NAN,
            Some(Ordering::Less) => a,
            Some(_) => b,
        }
    });
    println!("{}", min);
}

也许是这样

fn main() {
    use std::cmp::Ordering;
    let mut x = [2.0, 1.0, -10.0, 5.0];
    x.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));
    println!("min in x: {:?}", x);
}

---

我遇到的一件事是，

sort\u by

在适当的位置对向量进行变异，因此您不能直接在链中使用它。

如果您知道您的数据不包含NaN，则通过展开比较来断言这一事实：

fn example(x: &[f64]) -> Option<f64> {
    x.iter()
        .cloned()
        .min_by(|a, b| a.partial_cmp(b).expect("Tried to compare a NaN"))
}

Some（NaN）
部分（1.0）

std:：cmp:：partial_min不再存在。

use std::cmp::Ordering;

fn example(x: &[f64]) -> Option<f64> {
    x.iter()
        .cloned()
        .min_by(|a, b| {
            // all NaNs are greater than regular numbers
            match (a.is_nan(), b.is_nan()) {
                (true, true) => Ordering::Equal,
                (true, false) => Ordering::Greater,
                (false, true) => Ordering::Less,
                _ => a.partial_cmp(b).unwrap(),
            }
        })
}

use std::cmp::Ordering;
use std::f64;

fn example(x: &[f64]) -> Option<f64> {
    x.iter()
        .cloned()
        .min_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal))
}

fn main() {
    println!("{:?}", example(&[f64::NAN, 1.0]));
    println!("{:?}", example(&[1.0, f64::NAN]));
}