minmax-cli 0.1.0-beta.7

programs computing min and max argument values
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/*
min + max cli programs

implementation by Radim Kolar <hsn@sendmail.cz> 2026
https://gitlab.com/hsn10/minmax-cli

This is free and unencumbered software released into the public domain.
SPDX-License-Identifier: Unlicense OR CC0-1.0

For more information, please refer to <http://unlicense.org/>
or <https://creativecommons.org/publicdomain/zero/1.0/>
*/

const VERSION: &str = env!("CARGO_PKG_VERSION");

const ARGS: &str = "v?aA";

fn do_help() {
   println!("{} [-v | -? ] | [ -a | -A ] <number> ...", NAME);
   println!("");
   println!("Find and print the {} value from a list of provided numbers.", ACTION);
   println!("");
   println!("Options");
   println!("  -v  Print program version and exit.");
   println!("  -?  Show this help message.");
   println!("  -a  Compare numbers by their absolute value instead of their raw value.");
   println!("  -A  Print absolute value of returned number. Implies -a.");
   println!("");
   println!("Exit Codes");
   println!("  0   Success");
   println!("  1   No numeric arguments provided");
   println!("  2   One or more numeric arguments failed to parse or were invalid");
   println!("");
   println!("This is free and unencumbered software released into the public domain.");
}

pub fn index_of_<F>(numbers: &[f64], mut cmp: F) -> usize
where
   F: FnMut(&f64, &f64) -> std::cmp::Ordering,
{
   numbers
      .iter()
      .enumerate()
      .filter(|(_, &v)| v.is_finite()) // removes NaN and ±∞
      .min_by(|(_, a), (_, b)| cmp(a, b))
      .expect("All values are NaN or Infinite")
      .0
}

#[cfg(test)]
mod indexmin_tests;

/**
  converts positional arguments into floats.

  ## Returns
  true - if all arguments were succesfully parsed
  false - one or more argument failed to parse, is NaN or Infinite.
*/
pub fn args_as_floats(g: &getopt2::getopt, numbers: &mut Vec<f64>) -> bool {
   numbers.clear();
   let mut parse_fail = false;
   /* parse command line arguments as f64 numbers */
   for n_str in g.iter() {
      debug_assert!({
         println!("parsing n_str='{}'", n_str);
         true
      });
      match n_str.parse::<f64>() {
         Ok(num) => {
            // Check if the parsed number is NaN or infinite
            if num.is_nan() {
               eprintln!("Error parsing '{}': NaN values are not allowed.", n_str);
               parse_fail = true;
            } else if num.is_infinite() {
               eprintln!("Error parsing '{}': Infinite values are not allowed.", n_str);
               parse_fail = true;
            } else {
               // If it's a valid finite number, push it
               numbers.push(num);
            }
         }
         Err(e) => {
            eprintln!("Error parsing '{}': {}", n_str, e);
            parse_fail = true
         }
      }
   }
   !parse_fail
}

fn to_comparable_numbers(numbers: &[f64], use_abs: bool) -> Vec<f64> {
   let mut comparable_numbers = Vec::<f64>::with_capacity(numbers.len());
   for &n in numbers.iter() {
      if use_abs {
         comparable_numbers.push(n.abs());
      } else {
         comparable_numbers.push(n);
      }
   }
   comparable_numbers
}

use getopt2::hideBin;
use std::process::ExitCode;

/**
  ExitCode:
  1. 0 - OK
  2. 1 - Numeric arguments are missing
  3. 2 - Arguments can't be parsed as numbers
*/
fn main() -> ExitCode {
   let g = getopt2::new(hideBin(std::env::args()), ARGS).unwrap();
   if g.has('v') {
      println!("{}", VERSION);
      ExitCode::SUCCESS
   } else if g.has('?') {
      do_help();
      ExitCode::SUCCESS
   } else if g.len() == 0 {
      // no numeric arguments found
      do_help();
      ExitCode::from(1)
   } else {
      // main program logic
      let use_abs = g.has('a') || g.has('A');
      let mut numbers: Vec<f64> = Vec::with_capacity(g.len());

      if !args_as_floats(&g, &mut numbers) {
         ExitCode::from(2)
      } else {
         /* convert numbers to comparable numbers, optionaly use abs value */
         let comparable_numbers: Vec<f64> = to_comparable_numbers(&numbers, use_abs);
         /* find lowest number */
         let i = index_of_(&comparable_numbers, num_cmp());
         /* output absolute value on -A */
         if g.has('A') {
            numbers.iter_mut().for_each(|x| *x = x.abs());
         }
         println!("{}", numbers[i]);

         ExitCode::SUCCESS
      }
   }
}