249 lines
6.3 KiB
Rust
249 lines
6.3 KiB
Rust
/*
|
||
* Copyright (c) 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/.
|
||
*
|
||
* This file incorporates work covered by the following copyright and permission
|
||
* notice:
|
||
*
|
||
* MIT License
|
||
*
|
||
* Copyright (c) 2022 Lilly Cham
|
||
*
|
||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||
* copy of this software and associated documentation files
|
||
* (the "Software"), to deal in the Software without restriction, including
|
||
* without limitation the rights
|
||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||
* sell copies of the Software, and to permit persons to whom the Software
|
||
* is furnished to do so, subject to the following conditions:
|
||
*
|
||
* The above copyright notice and this permission notice shall be included
|
||
* in all copies or substantial portions of the Software.
|
||
*
|
||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
||
* NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
||
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
*/
|
||
|
||
use std::{
|
||
collections::VecDeque,
|
||
env::args,
|
||
fmt::{ self, Display, Formatter },
|
||
io::stdin,
|
||
process::ExitCode,
|
||
};
|
||
|
||
use CalcType::*;
|
||
|
||
extern crate sysexits;
|
||
|
||
use sysexits::EX_DATAERR;
|
||
|
||
#[derive(Clone, PartialEq, PartialOrd, Debug)]
|
||
// enum CalcType is a type containing operations used in the calculator
|
||
enum CalcType {
|
||
Add,
|
||
Subtract,
|
||
Multiply,
|
||
Divide,
|
||
Power,
|
||
Floor,
|
||
Modulo,
|
||
Val(f64),
|
||
Invalid(String),
|
||
}
|
||
|
||
impl From<&str> for CalcType {
|
||
fn from(value: &str) -> Self {
|
||
match value {
|
||
"+" => Add,
|
||
"-" | "−" => Subtract,
|
||
"*" | "×" => Multiply,
|
||
"/" | "÷" => Divide,
|
||
"^" | "**" => Power,
|
||
"//" => Floor,
|
||
"%" => Modulo,
|
||
_ => {
|
||
match value.parse::<f64>() {
|
||
Ok(x) => Val(x),
|
||
Err(_) => Invalid(value.to_owned()),
|
||
}
|
||
},
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Display for CalcType {
|
||
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
|
||
let y: String;
|
||
write!(f, "{}", match self {
|
||
Add => "addition",
|
||
Subtract => "subtraction",
|
||
Multiply => "multiplication",
|
||
Divide => "division",
|
||
Power => "exponentiation",
|
||
Floor => "floor division",
|
||
Modulo => "modulus",
|
||
Val(x) => {
|
||
y = x.to_string(); &y
|
||
},
|
||
Invalid(i) => {
|
||
y = i.to_string(); &y
|
||
},
|
||
})
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
struct EvaluationError {
|
||
message: String,
|
||
code: i32,
|
||
}
|
||
|
||
// I’m no math nerd but I want the highest possible approximation of 0.9
|
||
// repeating and it seems this can give it to me
|
||
const PRECISION_MOD: f64 = 0.9 + f64::EPSILON * 100.0;
|
||
|
||
fn eval(
|
||
input: &str,
|
||
initial_stack: VecDeque<f64>,
|
||
) -> Result<(VecDeque<f64>, bool), EvaluationError> {
|
||
let mut stack = initial_stack;
|
||
let mut oper = false;
|
||
|
||
if input.is_empty() {
|
||
stack.clear();
|
||
return Ok((stack, oper));
|
||
}
|
||
|
||
// Split the input into tokens.
|
||
let mut toks: VecDeque<CalcType> = input
|
||
.split_whitespace()
|
||
.rev()
|
||
.map(|t| CalcType::from(t))
|
||
.collect();
|
||
let mut ops: VecDeque<CalcType> = VecDeque::new();
|
||
|
||
while let Some(n) = toks.pop_back() {
|
||
match n {
|
||
Val(v) => stack.push_back(v),
|
||
Invalid(i) => {
|
||
return Err(EvaluationError {
|
||
message: format!("{}: Invalid token", i),
|
||
code: EX_DATAERR,
|
||
})
|
||
},
|
||
op => {
|
||
ops.push_back(op.clone());
|
||
oper = true;
|
||
|
||
let vals = (
|
||
stack.pop_back(),
|
||
stack.pop_back(),
|
||
);
|
||
|
||
if let (Some(x), Some(y)) = vals {
|
||
match op {
|
||
Add => stack.push_back(y + x),
|
||
Subtract => stack.push_back(y - x),
|
||
Multiply => stack.push_back(y * x),
|
||
Divide => stack.push_back(y / x),
|
||
Power => stack.push_back(y.powf(x)),
|
||
Floor => stack.push_back((y / x).floor()),
|
||
Modulo => stack.push_back(y % x),
|
||
_ => {},
|
||
};
|
||
} else {
|
||
return Err(EvaluationError {
|
||
message: format!("{}: Unexpected operation", op),
|
||
code: EX_DATAERR,
|
||
})
|
||
}
|
||
},
|
||
};
|
||
}
|
||
|
||
Ok((stack, oper))
|
||
}
|
||
|
||
// Round a float to the given precision level
|
||
fn round_precise(value: &f64, precision: usize) -> f64 {
|
||
let multiplier = 10_f64.powi(precision as i32);
|
||
(value * multiplier).round() / multiplier
|
||
}
|
||
|
||
fn main() -> ExitCode {
|
||
let argv = args().collect::<Vec<String>>();
|
||
let mut stack = VecDeque::new();
|
||
let mut buf = String::new();
|
||
// Set floating-point precision for correcting rounding errors based on
|
||
// machine epsilon
|
||
let precision = (-f64::EPSILON.log10() * PRECISION_MOD).ceil() as usize;
|
||
|
||
if argv.get(1).is_none() {
|
||
while let Ok(_) = stdin().read_line(&mut buf) {
|
||
match eval(&buf.trim(), stack) {
|
||
Ok(s) => {
|
||
buf.clear();
|
||
stack = s.0.clone();
|
||
|
||
let val = match stack.iter().last() {
|
||
Some(v) => v,
|
||
None => break,
|
||
};
|
||
|
||
if s.1 == false { continue; }
|
||
|
||
println!("{}", round_precise(val, precision).to_string());
|
||
},
|
||
Err(err) => {
|
||
eprintln!("{}: {}", argv[0], err.message);
|
||
return ExitCode::from(err.code as u8);
|
||
},
|
||
};
|
||
}
|
||
} else {
|
||
let input = argv
|
||
.iter()
|
||
.skip(1)
|
||
.map(|x| x.to_owned())
|
||
.collect::<Vec<String>>()
|
||
.join(" ");
|
||
|
||
match eval(&input, stack) {
|
||
Ok(s) => {
|
||
stack = s.0.clone();
|
||
|
||
let val = match stack.iter().last() {
|
||
Some(v) => v,
|
||
None => return ExitCode::from(0),
|
||
};
|
||
|
||
println!("{}", round_precise(val, precision).to_string())
|
||
},
|
||
Err(err) => {
|
||
eprintln!("{}: {}", argv[0], err.message);
|
||
return ExitCode::from(err.code as u8);
|
||
},
|
||
};
|
||
}
|
||
ExitCode::from(0)
|
||
}
|