# **min-max**: `max!` and `min!` macros for Rust
[![crates.io](https://img.shields.io/crates/d/min-max.svg)](https://crates.io/crates/min-max)
[![crates.io](https://img.shields.io/crates/v/min-max.svg)](https://crates.io/crates/min-max)
[![crates.io](https://img.shields.io/crates/l/min-max.svg)](https://crates.io/crates/min-max)
## Why?
Sometimes you want to find the maximum of a bunch of **scalars**. Usually you would write something like `max(x1, max(x2, max(x3, x4)))`. The `max!` macro provided by this crate simplifies that to `max!(x1, x2, x3, x4)`. (Note, for an **iterable** data structure, you would use `xx.iter().max()`).
## Usage
Add this to your `Cargo.toml`:
```toml
min-max = "0.1"
```
Then, for example:
```rust
use min_max::*;
fn main() {
let max = max!(1, 5, 7, 2, 4, 9, 3);
assert_eq!(max, 9);
let min = min!(1, 5, 7, 2, 4, 9, 3);
assert_eq!(min, 1);
let min_max = min_max!(1, 5, 7, 2, 4, 9, 3);
assert_eq!(min_max, (min, max));
}
```
### Does it work on floats?
Yep. But you need to use `max_partial!`/`min_partial!`
```rust
use min_max::*;
fn main() {
let partial_max = max_partial!(1.8f64, 5.8, 7.8, 2.8, 4.8, 9.8, 3.8);
assert!((9.8 - partial_max).abs() < 1e-5);
let partial_min = min_partial!(1.8f64, 5.8, 7.8, 2.8, 4.8, 9.8, 3.8);
assert!((1.8 - partial_min).abs() < 1e-5);
}
```
### What about `NaN`?
Do not use when your data contains `NaN`. When `NaN` is at the end, `NaN` is returned. Otherwise, the min/max excluding `NaN` is returned.
```rust
use min_max::*;
fn main() {
let partial_max = max_partial!(1.8, 5.8, f64::NAN, 2.8, 4.8, 9.8, 3.8);
assert!((9.8 - partial_max).abs() < 1e-5);
let partial_max = max_partial!(1.8, 5.8, 2.8, 4.8, 9.8, 3.8, f64::NAN);
assert!(partial_max.is_nan());
let partial_min = min_partial!(1.8, 5.8, f64::NAN, 2.8, 4.8, 9.8, 3.8);
assert!((1.8 - partial_min).abs() < 1e-5);
let partial_min = max_partial!(1.8, 5.8, 2.8, 4.8, 9.8, 3.8, f64::NAN);
assert!(partial_min.is_nan());
}
```
### Can I use custom types?
Sure, why not?
```rust
use min_max::*;
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Copy)]
struct Point {
x: u16,
y: u16,
}
fn main() {
let a = Point { x: 5, y: 8 };
let b = Point { x: 10, y: 92 };
let c = Point { x: 0, y: 3 };
let max = max!(a, b, c);
assert_eq!(max, b);
}
```
## What's going on under the hood?
Well, `max!(x1, x2, x3)` expands to:
```rust
std::cmp::max(x1, std::cmp::max(x2, std::cmp::max(x3)))
```
and so on. `min!` works similarly, but with `std::cmp::min`.
`min_partial!` and `max_partial` uses the `min` and `max` functions from the [`partial-min-max` crate](https://crates.io/crates/partial-min-max).