forked from bonsai/harakit
117 lines
3.1 KiB
Rust
117 lines
3.1 KiB
Rust
/*
|
||
* Copyright (c) 2023–2024 Emma Tebibyte <emma@tebibyte.media>
|
||
* SPDX-License-Identifier: AGPL-3.0-or-later
|
||
*
|
||
* This program is free software: you can redistribute it and/or modify it under
|
||
* the terms of the GNU Affero General Public License as published by the Free
|
||
* Software Foundation, either version 3 of the License, or (at your option) any
|
||
* later version.
|
||
*
|
||
* This program is distributed in the hope that it will be useful, but WITHOUT
|
||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
||
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
||
* details.
|
||
*
|
||
* You should have received a copy of the GNU Affero General Public License
|
||
* along with this program. If not, see https://www.gnu.org/licenses/.
|
||
*/
|
||
|
||
use std::{
|
||
cmp::Ordering,
|
||
env::args,
|
||
io::{ stdin, stdout, Write },
|
||
process::{ ExitCode, exit },
|
||
};
|
||
|
||
extern crate strerror;
|
||
extern crate sysexits;
|
||
|
||
use strerror::StrError;
|
||
use sysexits::{ EX_DATAERR, EX_IOERR, EX_SOFTWARE };
|
||
|
||
/* list of SI prefixes */
|
||
const LIST: [(u32, &str); 10] = [
|
||
(3, "k"), /* kilo */
|
||
(6, "M"), /* mega */
|
||
(9, "G"), /* giga */
|
||
(12, "T"), /* tera */
|
||
(15, "P"), /* peta */
|
||
(18, "E"), /* exa */
|
||
(21, "Z"), /* zetta */
|
||
(24, "Y"), /* yotta */
|
||
(27, "R"), /* ronna */
|
||
(30, "Q"), /* quetta */
|
||
];
|
||
|
||
fn convert(input: u128) -> Result<(f64, (u32, &'static str)), String> {
|
||
/* preserve decimal places in output by casting to a float */
|
||
let mut out = (input as f64, (0_u32, ""));
|
||
|
||
if input < 1000 { return Ok(out); } /* too low to convert */
|
||
|
||
for (n, p) in LIST {
|
||
let c = match 10_u128.checked_pow(n) {
|
||
Some(c) => c,
|
||
None => { /* too big for the laws of computing :( */
|
||
return Err(format!("10^{}: Integer overflow", n.to_string()));
|
||
},
|
||
};
|
||
|
||
match c.cmp(&input) {
|
||
Ordering::Less => { /* c < input */
|
||
/* the program will keep assigning out every loop until either
|
||
* the list runs out of higher prefix bases or the input is
|
||
* greater than the prefix base */
|
||
out = (input as f64 / c as f64, (n, p));
|
||
},
|
||
Ordering::Equal => { /* c == input */
|
||
return Ok((input as f64 / c as f64, (n, p)));
|
||
},
|
||
Ordering::Greater => {}, /* c > input */
|
||
};
|
||
}
|
||
|
||
Ok(out)
|
||
}
|
||
|
||
fn main() -> ExitCode {
|
||
let argv = args().collect::<Vec<String>>();
|
||
let mut buf = String::new();
|
||
|
||
while let Ok(_) = stdin().read_line(&mut buf) {
|
||
if buf.is_empty() { return ExitCode::SUCCESS; }
|
||
|
||
let n: u128 = match buf.trim().parse() {
|
||
Ok(f) => {
|
||
buf.clear();
|
||
f
|
||
},
|
||
Err(err) => {
|
||
eprintln!("{}: {}", argv[0], err);
|
||
return ExitCode::from(EX_DATAERR as u8);
|
||
},
|
||
};
|
||
|
||
let (number, prefix) = match convert(n) {
|
||
Ok(x) => x,
|
||
Err(err) => {
|
||
eprintln!("{}: {}", argv[0], err);
|
||
return ExitCode::from(EX_SOFTWARE as u8);
|
||
},
|
||
};
|
||
|
||
let si_prefix = format!("{}B", prefix.1);
|
||
|
||
/* round output number to one decimal place */
|
||
let out = ((number * 10.0).round() / 10.0).to_string();
|
||
|
||
stdout().write_all(format!("{} {}\n", out, si_prefix).as_bytes())
|
||
.unwrap_or_else(|e| {
|
||
eprintln!("{}: {}", argv[0], e.strerror());
|
||
exit(EX_IOERR);
|
||
});
|
||
}
|
||
|
||
ExitCode::SUCCESS
|
||
}
|