What is the idiomatic way to get the index of a maximum or minimum floating point value in a slice or Vec in Rust?

Is there a reason why this wouldn't work?

use std::cmp::Ordering;

fn example(nets: &Vec<f32>) {
    let index_of_max: Option<usize> = nets
        .iter()
        .enumerate()
        .max_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Equal))
        .map(|(index, _)| index);
}

The reason why this is tricky is because f32 does not implement Ord. That is because NaN values prevent floating point numbers from forming a total order, which violates the contract of Ord.

There are 3rd party crates that work around this by defining a numeric type wrapper which is not allowed to contain a NaN. One example is ordered-float. If you use this crate to first prepare the collection to contain NotNan values, then you can write code very close to your original idea:

use ordered_float::NotNan;

let non_nan_floats: Vec<_> = nets.iter()
    .cloned()
    .map(NotNan::new)       // Attempt to convert each f32 to a NotNan
    .filter_map(Result::ok) // Unwrap the `NotNan`s and filter out the `NaN` values 
    .collect();

let max = non_nan_floats.iter().max().unwrap();
let index = non_nan_floats.iter().position(|element| element == max).unwrap();

Add this to Cargo.toml:

[dependencies]
ordered-float = "1.0.1"

---

Bonus material: The type conversion can be made truly zero-cost (assuming you are really sure that there are no NaN values!), by taking advantage of the fact that NotNan has a transparent representation:

let non_nan_floats: Vec<NotNan<f32>> = unsafe { mem::transmute(nets) };

You can find the maximum value with the following:

let mut max_value = my_vec.iter().fold(0.0f32, |max, &val| if val > max{ val } else{ max });

After finding max_value you can track its position in the vector itself:

let index = my_vec.iter().position(|&r| r == max_value).unwrap();

To get this result you need to iterate twice over the same vector. To improve the performance, you can return the index value with the max value as tuple in the fold iteration.

Playground