1339 lines
38 KiB
Rust
1339 lines
38 KiB
Rust
//! Calculator logic (standard / formula).
|
||
//!
|
||
//! Uses exact rational arithmetic when possible so that e.g. `1÷3×3 = 1`
|
||
//! instead of a float residue like `0.999999999999`.
|
||
|
||
use std::fmt;
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum Op {
|
||
Add,
|
||
Sub,
|
||
Mul,
|
||
Div,
|
||
}
|
||
|
||
impl Op {
|
||
pub fn symbol(self) -> &'static str {
|
||
match self {
|
||
Op::Add => "+",
|
||
Op::Sub => "−",
|
||
Op::Mul => "×",
|
||
Op::Div => "÷",
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum CalcError {
|
||
DivByZero,
|
||
Overflow,
|
||
Invalid,
|
||
}
|
||
|
||
impl CalcError {
|
||
pub fn message(self) -> &'static str {
|
||
match self {
|
||
CalcError::DivByZero => "Cannot divide by zero",
|
||
CalcError::Overflow => "Overflow",
|
||
CalcError::Invalid => "Invalid input",
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
pub enum StdPanel {
|
||
/// Classic immediate calculator (Windows-like chaining).
|
||
Standard,
|
||
/// Build a full expression, evaluate on `=` with operator precedence.
|
||
Formula,
|
||
}
|
||
|
||
/// Exact rational number (always reduced, denominator > 0).
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
struct Rational {
|
||
num: i128,
|
||
den: i128,
|
||
}
|
||
|
||
impl Rational {
|
||
fn new(num: i128, den: i128) -> Result<Self, CalcError> {
|
||
if den == 0 {
|
||
return Err(CalcError::DivByZero);
|
||
}
|
||
let (mut num, mut den) = (num, den);
|
||
if den < 0 {
|
||
num = -num;
|
||
den = -den;
|
||
}
|
||
let g = gcd(num.unsigned_abs(), den.unsigned_abs());
|
||
Ok(Self {
|
||
num: num / g as i128,
|
||
den: den / g as i128,
|
||
})
|
||
}
|
||
|
||
fn from_i128(n: i128) -> Self {
|
||
Self { num: n, den: 1 }
|
||
}
|
||
|
||
/// Parse a decimal literal like `12`, `-3.5`, `0.001`, `1.5e-9` into an
|
||
/// exact fraction (exponent shifts by exact powers of ten).
|
||
fn parse(s: &str) -> Result<Self, CalcError> {
|
||
let s = s.trim();
|
||
if s.is_empty() || s == "." || s == "-" || s == "-." {
|
||
return Err(CalcError::Invalid);
|
||
}
|
||
// Split off an optional exponent: `1e-15`, `2.5E+3`.
|
||
let (body, exp) = match s.split_once(['e', 'E']) {
|
||
Some((b, e)) => {
|
||
let exp: i32 = e.parse().map_err(|_| CalcError::Invalid)?;
|
||
(b, exp)
|
||
}
|
||
None => (s, 0i32),
|
||
};
|
||
let neg = body.starts_with('-');
|
||
let b = if neg { &body[1..] } else { body };
|
||
|
||
let (int_part, frac_part) = match b.split_once('.') {
|
||
Some((a, c)) => (a, c),
|
||
None => (b, ""),
|
||
};
|
||
if int_part.is_empty() && frac_part.is_empty() {
|
||
return Err(CalcError::Invalid);
|
||
}
|
||
let int_part = if int_part.is_empty() { "0" } else { int_part };
|
||
let int_val: i128 = int_part.parse().map_err(|_| CalcError::Invalid)?;
|
||
let frac_digits = frac_part.len();
|
||
let frac_val: i128 = if frac_part.is_empty() {
|
||
0
|
||
} else {
|
||
frac_part.parse().map_err(|_| CalcError::Invalid)?
|
||
};
|
||
let den = pow10(frac_digits)?;
|
||
let num = int_val
|
||
.checked_mul(den)
|
||
.and_then(|v| v.checked_add(frac_val))
|
||
.ok_or(CalcError::Overflow)?;
|
||
let num = if neg { -num } else { num };
|
||
|
||
// Apply the exponent with exact power-of-ten arithmetic:
|
||
// value·10^exp = num·10^exp / 10^frac_digits.
|
||
let (num, den) = if exp >= 0 {
|
||
let e = exp as usize;
|
||
if e >= frac_digits {
|
||
(
|
||
num.checked_mul(pow10(e - frac_digits)?)
|
||
.ok_or(CalcError::Overflow)?,
|
||
1,
|
||
)
|
||
} else {
|
||
(num, den / pow10(e)?)
|
||
}
|
||
} else {
|
||
(
|
||
num,
|
||
den.checked_mul(pow10((-exp) as usize)?)
|
||
.ok_or(CalcError::Overflow)?,
|
||
)
|
||
};
|
||
Self::new(num, den)
|
||
}
|
||
|
||
fn to_f64(self) -> f64 {
|
||
self.num as f64 / self.den as f64
|
||
}
|
||
|
||
fn is_integer(self) -> bool {
|
||
self.den == 1
|
||
}
|
||
|
||
fn add(self, o: Self) -> Result<Self, CalcError> {
|
||
let num = self
|
||
.num
|
||
.checked_mul(o.den)
|
||
.and_then(|a| o.num.checked_mul(self.den).and_then(|b| a.checked_add(b)))
|
||
.ok_or(CalcError::Overflow)?;
|
||
let den = self.den.checked_mul(o.den).ok_or(CalcError::Overflow)?;
|
||
Self::new(num, den)
|
||
}
|
||
|
||
fn sub(self, o: Self) -> Result<Self, CalcError> {
|
||
self.add(Rational {
|
||
num: -o.num,
|
||
den: o.den,
|
||
})
|
||
}
|
||
|
||
fn mul(self, o: Self) -> Result<Self, CalcError> {
|
||
let num = self.num.checked_mul(o.num).ok_or(CalcError::Overflow)?;
|
||
let den = self.den.checked_mul(o.den).ok_or(CalcError::Overflow)?;
|
||
Self::new(num, den)
|
||
}
|
||
|
||
fn div(self, o: Self) -> Result<Self, CalcError> {
|
||
if o.num == 0 {
|
||
return Err(CalcError::DivByZero);
|
||
}
|
||
self.mul(Rational {
|
||
num: o.den,
|
||
den: o.num,
|
||
})
|
||
}
|
||
|
||
fn neg(self) -> Self {
|
||
Self {
|
||
num: -self.num,
|
||
den: self.den,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Numeric value: prefer exact rationals, fall back to float (√ etc.).
|
||
#[derive(Debug, Clone, Copy, PartialEq)]
|
||
enum Value {
|
||
Rat(Rational),
|
||
Float(f64),
|
||
}
|
||
|
||
impl Value {
|
||
fn from_entry(s: &str) -> Result<Self, CalcError> {
|
||
Ok(Value::Rat(Rational::parse(s)?))
|
||
}
|
||
|
||
fn from_f64(v: f64) -> Result<Self, CalcError> {
|
||
if !v.is_finite() {
|
||
return Err(CalcError::Overflow);
|
||
}
|
||
if v == 0.0 {
|
||
return Ok(Value::Rat(Rational::from_i128(0)));
|
||
}
|
||
// Prefer exact integer when float is (almost) integral. Never snap a
|
||
// sub-unit magnitude to an integer: that turned 1e-16 into `0`.
|
||
let r = v.round();
|
||
if r != 0.0 && (v - r).abs() < 1e-12 && v.abs() < 1e15 {
|
||
return Ok(Value::Rat(Rational::from_i128(r as i128)));
|
||
}
|
||
Ok(Value::Float(v))
|
||
}
|
||
|
||
fn to_f64(self) -> f64 {
|
||
match self {
|
||
Value::Rat(r) => r.to_f64(),
|
||
Value::Float(f) => f,
|
||
}
|
||
}
|
||
|
||
fn apply(self, op: Op, other: Self) -> Result<Self, CalcError> {
|
||
match (self, other) {
|
||
(Value::Rat(a), Value::Rat(b)) => {
|
||
let r = match op {
|
||
Op::Add => a.add(b)?,
|
||
Op::Sub => a.sub(b)?,
|
||
Op::Mul => a.mul(b)?,
|
||
Op::Div => a.div(b)?,
|
||
};
|
||
Ok(Value::Rat(r))
|
||
}
|
||
(a, b) => {
|
||
let (x, y) = (a.to_f64(), b.to_f64());
|
||
let r = match op {
|
||
Op::Add => x + y,
|
||
Op::Sub => x - y,
|
||
Op::Mul => x * y,
|
||
Op::Div => {
|
||
if y == 0.0 {
|
||
return Err(CalcError::DivByZero);
|
||
}
|
||
x / y
|
||
}
|
||
};
|
||
Value::from_f64(r)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn format(self) -> String {
|
||
match self {
|
||
Value::Rat(r) => format_rational(r),
|
||
Value::Float(f) => format_float(f),
|
||
}
|
||
}
|
||
}
|
||
|
||
#[derive(Debug, Clone)]
|
||
pub struct Calculator {
|
||
panel: StdPanel,
|
||
/// Digits currently being entered (or last result as string).
|
||
entry: String,
|
||
/// Exact value behind `entry` when not typing (avoids `1/3` → `"0.333…"` → inexact parse).
|
||
entry_value: Option<Value>,
|
||
/// True while the user is typing a new number.
|
||
typing: bool,
|
||
/// Left operand waiting for the next number / equals (standard panel).
|
||
pending: Option<Value>,
|
||
/// Pending binary operator (standard panel).
|
||
op: Option<Op>,
|
||
/// Expression line above the main display.
|
||
expression: String,
|
||
/// Formula panel: tokens / text of the expression being built (without current entry).
|
||
formula: String,
|
||
/// After `=` in formula mode, next digit starts fresh.
|
||
formula_done: bool,
|
||
/// Last error, if any.
|
||
error: Option<CalcError>,
|
||
/// Memory register.
|
||
memory: Value,
|
||
/// Whether memory has been set (for UI hint).
|
||
memory_set: bool,
|
||
}
|
||
|
||
impl Default for Calculator {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
impl Calculator {
|
||
pub fn new() -> Self {
|
||
Self {
|
||
panel: StdPanel::Standard,
|
||
entry: "0".into(),
|
||
entry_value: Some(Value::Rat(Rational::from_i128(0))),
|
||
typing: false,
|
||
pending: None,
|
||
op: None,
|
||
expression: String::new(),
|
||
formula: String::new(),
|
||
formula_done: false,
|
||
error: None,
|
||
memory: Value::Rat(Rational::from_i128(0)),
|
||
memory_set: false,
|
||
}
|
||
}
|
||
|
||
pub fn panel(&self) -> StdPanel {
|
||
self.panel
|
||
}
|
||
|
||
pub fn set_panel(&mut self, panel: StdPanel) {
|
||
if self.panel == panel {
|
||
return;
|
||
}
|
||
let mem = (self.memory, self.memory_set);
|
||
*self = Self::new();
|
||
self.panel = panel;
|
||
self.memory = mem.0;
|
||
self.memory_set = mem.1;
|
||
}
|
||
|
||
pub fn display(&self) -> &str {
|
||
if let Some(err) = self.error {
|
||
return err.message();
|
||
}
|
||
&self.entry
|
||
}
|
||
|
||
pub fn expression(&self) -> &str {
|
||
&self.expression
|
||
}
|
||
|
||
pub fn has_memory(&self) -> bool {
|
||
self.memory_set
|
||
}
|
||
|
||
pub fn clear_all(&mut self) {
|
||
let panel = self.panel;
|
||
let memory = self.memory;
|
||
let memory_set = self.memory_set;
|
||
*self = Self::new();
|
||
self.panel = panel;
|
||
self.memory = memory;
|
||
self.memory_set = memory_set;
|
||
}
|
||
|
||
pub fn clear_entry(&mut self) {
|
||
self.error = None;
|
||
self.entry = "0".into();
|
||
self.entry_value = Some(Value::Rat(Rational::from_i128(0)));
|
||
self.typing = false;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
|
||
pub fn backspace(&mut self) {
|
||
if self.error.is_some() {
|
||
self.clear_entry();
|
||
return;
|
||
}
|
||
if self.panel == StdPanel::Formula && self.formula_done {
|
||
return;
|
||
}
|
||
if !self.typing {
|
||
if self.panel == StdPanel::Formula && !self.formula.is_empty() {
|
||
// Remove trailing operator / open paren from formula.
|
||
while self.formula.ends_with(' ') {
|
||
self.formula.pop();
|
||
}
|
||
if let Some(ch) = self.formula.chars().last() {
|
||
if "＋+−-×*÷/(".contains(ch) || ch == '−' || ch == '×' || ch == '÷' {
|
||
self.formula.pop();
|
||
while self.formula.ends_with(' ') {
|
||
self.formula.pop();
|
||
}
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
self.entry.pop();
|
||
if self.entry.is_empty() || self.entry == "-" {
|
||
self.entry = "0".into();
|
||
self.typing = false;
|
||
self.entry_value = Some(Value::Rat(Rational::from_i128(0)));
|
||
} else {
|
||
self.entry_value = None;
|
||
}
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
|
||
pub fn input_digit(&mut self, d: char) {
|
||
debug_assert!(d.is_ascii_digit());
|
||
if self.error.is_some() {
|
||
self.clear_all();
|
||
}
|
||
if self.panel == StdPanel::Formula && self.formula_done {
|
||
self.formula.clear();
|
||
self.expression.clear();
|
||
self.formula_done = false;
|
||
self.entry = d.to_string();
|
||
self.entry_value = None;
|
||
self.typing = true;
|
||
self.sync_formula_expression();
|
||
return;
|
||
}
|
||
if !self.typing {
|
||
self.entry = d.to_string();
|
||
self.entry_value = None;
|
||
self.typing = true;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
return;
|
||
}
|
||
if self.entry == "0" {
|
||
self.entry = d.to_string();
|
||
} else if self.entry == "-0" {
|
||
self.entry = format!("-{d}");
|
||
} else if digit_count(&self.entry) < 40 && significant_digits(&self.entry) < 16 {
|
||
self.entry.push(d);
|
||
}
|
||
self.entry_value = None;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
|
||
pub fn input_dot(&mut self) {
|
||
if self.error.is_some() {
|
||
self.clear_all();
|
||
}
|
||
if self.panel == StdPanel::Formula && self.formula_done {
|
||
self.formula.clear();
|
||
self.expression.clear();
|
||
self.formula_done = false;
|
||
self.entry = "0.".into();
|
||
self.entry_value = None;
|
||
self.typing = true;
|
||
self.sync_formula_expression();
|
||
return;
|
||
}
|
||
if !self.typing {
|
||
self.entry = "0.".into();
|
||
self.entry_value = None;
|
||
self.typing = true;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
return;
|
||
}
|
||
if !self.entry.contains('.') {
|
||
self.entry.push('.');
|
||
self.entry_value = None;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn negate(&mut self) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
if self.panel == StdPanel::Formula && self.formula_done {
|
||
if let Ok(v) = self.current_value() {
|
||
self.set_entry_value(v.apply(Op::Mul, Value::Rat(Rational::from_i128(-1))).unwrap_or(v));
|
||
}
|
||
return;
|
||
}
|
||
if let Ok(v) = self.current_value() {
|
||
match v {
|
||
Value::Rat(r) => self.set_entry_value(Value::Rat(r.neg())),
|
||
Value::Float(f) => self.set_entry_value(Value::Float(-f)),
|
||
}
|
||
self.typing = true;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn percent(&mut self) {
|
||
if self.error.is_some() || self.panel == StdPanel::Formula {
|
||
return;
|
||
}
|
||
let Ok(cur) = self.current_value() else {
|
||
return;
|
||
};
|
||
let result = match (self.pending, self.op) {
|
||
(Some(a), Some(Op::Add | Op::Sub)) => a
|
||
.apply(Op::Mul, cur)
|
||
.and_then(|p| p.apply(Op::Div, Value::Rat(Rational::from_i128(100)))),
|
||
_ => cur.apply(Op::Div, Value::Rat(Rational::from_i128(100))),
|
||
};
|
||
match result {
|
||
Ok(v) => {
|
||
self.set_entry_value(v);
|
||
self.typing = false;
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
|
||
pub fn reciprocal(&mut self) {
|
||
self.unary(|x| Value::Rat(Rational::from_i128(1)).apply(Op::Div, x));
|
||
}
|
||
|
||
pub fn square(&mut self) {
|
||
self.unary(|x| x.apply(Op::Mul, x));
|
||
}
|
||
|
||
pub fn sqrt(&mut self) {
|
||
self.unary(|x| {
|
||
let f = x.to_f64();
|
||
if f < 0.0 {
|
||
Err(CalcError::Invalid)
|
||
} else {
|
||
Value::from_f64(f.sqrt())
|
||
}
|
||
});
|
||
}
|
||
|
||
pub fn set_op(&mut self, op: Op) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
match self.panel {
|
||
StdPanel::Standard => self.set_op_standard(op),
|
||
StdPanel::Formula => self.set_op_formula(op),
|
||
}
|
||
}
|
||
|
||
pub fn paren_open(&mut self) {
|
||
if self.panel != StdPanel::Formula || self.error.is_some() {
|
||
return;
|
||
}
|
||
if self.formula_done {
|
||
self.formula.clear();
|
||
self.formula_done = false;
|
||
self.entry = "0".into();
|
||
self.typing = false;
|
||
}
|
||
// If a number was being typed, imply multiply: 2(3+1)
|
||
if self.typing {
|
||
self.flush_entry_to_formula();
|
||
if !self.formula.is_empty() && !self.formula.ends_with('(') && !self.formula.ends_with(' ') {
|
||
// already flushed number; add × before (
|
||
// flush_entry_to_formula already appended the number
|
||
}
|
||
let trimmed = self.formula.trim_end();
|
||
if trimmed
|
||
.chars()
|
||
.last()
|
||
.is_some_and(|c| c.is_ascii_digit() || c == ')')
|
||
{
|
||
self.formula.push_str(" × ");
|
||
}
|
||
} else if !self.formula.is_empty() {
|
||
let trimmed = self.formula.trim_end();
|
||
if trimmed
|
||
.chars()
|
||
.last()
|
||
.is_some_and(|c| c.is_ascii_digit() || c == ')')
|
||
{
|
||
self.formula.push_str(" × ");
|
||
}
|
||
}
|
||
self.formula.push('(');
|
||
self.entry = "0".into();
|
||
self.typing = false;
|
||
self.sync_formula_expression();
|
||
}
|
||
|
||
pub fn paren_close(&mut self) {
|
||
if self.panel != StdPanel::Formula || self.error.is_some() {
|
||
return;
|
||
}
|
||
if self.formula_done {
|
||
return;
|
||
}
|
||
let opens = self.formula.chars().filter(|&c| c == '(').count();
|
||
let closes = self.formula.chars().filter(|&c| c == ')').count();
|
||
if opens <= closes {
|
||
return;
|
||
}
|
||
if self.typing || self.entry != "0" || !self.formula.ends_with('(') {
|
||
self.flush_entry_to_formula();
|
||
}
|
||
self.formula.push(')');
|
||
self.entry = "0".into();
|
||
self.typing = false;
|
||
self.sync_formula_expression();
|
||
}
|
||
|
||
pub fn equals(&mut self) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
match self.panel {
|
||
StdPanel::Standard => self.equals_standard(),
|
||
StdPanel::Formula => self.equals_formula(),
|
||
}
|
||
}
|
||
|
||
// --- Memory ---
|
||
|
||
pub fn memory_clear(&mut self) {
|
||
self.memory = Value::Rat(Rational::from_i128(0));
|
||
self.memory_set = false;
|
||
}
|
||
|
||
pub fn memory_recall(&mut self) {
|
||
if self.error.is_some() {
|
||
self.clear_all();
|
||
}
|
||
if self.panel == StdPanel::Formula && self.formula_done {
|
||
self.formula.clear();
|
||
self.formula_done = false;
|
||
}
|
||
self.set_entry_value(self.memory);
|
||
self.typing = false;
|
||
if self.panel == StdPanel::Formula {
|
||
self.sync_formula_expression();
|
||
}
|
||
}
|
||
|
||
pub fn memory_add(&mut self) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
if let Ok(v) = self.current_value() {
|
||
match self.memory.apply(Op::Add, v) {
|
||
Ok(m) => {
|
||
self.memory = m;
|
||
self.memory_set = true;
|
||
self.typing = false;
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn memory_sub(&mut self) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
if let Ok(v) = self.current_value() {
|
||
match self.memory.apply(Op::Sub, v) {
|
||
Ok(m) => {
|
||
self.memory = m;
|
||
self.memory_set = true;
|
||
self.typing = false;
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn memory_store(&mut self) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
if let Ok(v) = self.current_value() {
|
||
self.memory = v;
|
||
self.memory_set = true;
|
||
self.typing = false;
|
||
}
|
||
}
|
||
|
||
// --- standard panel ---
|
||
|
||
fn set_op_standard(&mut self, op: Op) {
|
||
if let Err(e) = self.commit_pending() {
|
||
self.fail(e);
|
||
return;
|
||
}
|
||
let Ok(v) = self.current_value() else {
|
||
return;
|
||
};
|
||
self.pending = Some(v);
|
||
self.op = Some(op);
|
||
self.expression = format!("{} {}", v.format(), op.symbol());
|
||
self.typing = false;
|
||
}
|
||
|
||
fn equals_standard(&mut self) {
|
||
let Some(op) = self.op else {
|
||
self.expression.clear();
|
||
self.typing = false;
|
||
return;
|
||
};
|
||
let Ok(b) = self.current_value() else {
|
||
return;
|
||
};
|
||
let a = self.pending.unwrap_or(b);
|
||
match a.apply(op, b) {
|
||
Ok(r) => {
|
||
self.expression = format!(
|
||
"{} {} {} =",
|
||
a.format(),
|
||
op.symbol(),
|
||
b.format()
|
||
);
|
||
self.set_entry_value(r);
|
||
self.pending = None;
|
||
self.op = None;
|
||
self.typing = false;
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
|
||
fn commit_pending(&mut self) -> Result<(), CalcError> {
|
||
let (Some(a), Some(op)) = (self.pending, self.op) else {
|
||
return Ok(());
|
||
};
|
||
if !self.typing {
|
||
return Ok(());
|
||
}
|
||
let b = self.current_value()?;
|
||
let r = a.apply(op, b)?;
|
||
self.set_entry_value(r);
|
||
self.pending = Some(r);
|
||
self.op = None;
|
||
self.typing = false;
|
||
Ok(())
|
||
}
|
||
|
||
// --- formula panel ---
|
||
|
||
fn set_op_formula(&mut self, op: Op) {
|
||
if self.formula_done {
|
||
// Continue from previous result: `ans + …`
|
||
self.formula.clear();
|
||
self.formula_done = false;
|
||
self.typing = true; // treat current entry as left operand
|
||
}
|
||
self.flush_entry_to_formula();
|
||
// Replace trailing operator if user changes mind: `1 +` then `-` → `1 −`
|
||
let trimmed = self.formula.trim_end();
|
||
if let Some(last) = trimmed.chars().last() {
|
||
if matches!(last, '+' | '−' | '×' | '÷' | '-' | '*' | '/') {
|
||
while self.formula.ends_with(' ') {
|
||
self.formula.pop();
|
||
}
|
||
self.formula.pop();
|
||
while self.formula.ends_with(' ') {
|
||
self.formula.pop();
|
||
}
|
||
}
|
||
}
|
||
if !self.formula.is_empty() {
|
||
self.formula.push(' ');
|
||
}
|
||
self.formula.push_str(op.symbol());
|
||
self.formula.push(' ');
|
||
self.entry = "0".into();
|
||
self.typing = false;
|
||
self.sync_formula_expression();
|
||
}
|
||
|
||
fn equals_formula(&mut self) {
|
||
let mut src = self.formula.clone();
|
||
let ends_with_paren = src.trim_end().ends_with(')');
|
||
if !ends_with_paren {
|
||
if !src.is_empty() && !src.ends_with(' ') && !src.ends_with('(') {
|
||
src.push(' ');
|
||
}
|
||
src.push_str(&self.entry);
|
||
} else if src.is_empty() {
|
||
src = self.entry.clone();
|
||
}
|
||
|
||
// Auto-close parentheses.
|
||
let opens = src.chars().filter(|&c| c == '(').count();
|
||
let closes = src.chars().filter(|&c| c == ')').count();
|
||
for _ in 0..opens.saturating_sub(closes) {
|
||
src.push(')');
|
||
}
|
||
|
||
match eval_expression(&src) {
|
||
Ok(v) => {
|
||
self.expression = format!("{} =", src);
|
||
self.set_entry_value(v);
|
||
self.formula.clear();
|
||
self.typing = false;
|
||
self.formula_done = true;
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
|
||
fn flush_entry_to_formula(&mut self) {
|
||
if !self.typing && self.entry == "0" && self.formula.trim_end().ends_with(')') {
|
||
return;
|
||
}
|
||
if !self.formula.is_empty()
|
||
&& !self.formula.ends_with(' ')
|
||
&& !self.formula.ends_with('(')
|
||
{
|
||
self.formula.push(' ');
|
||
}
|
||
self.formula.push_str(&self.entry);
|
||
self.typing = false;
|
||
}
|
||
|
||
fn sync_formula_expression(&mut self) {
|
||
if self.formula_done {
|
||
return;
|
||
}
|
||
let mut s = self.formula.clone();
|
||
if self.typing {
|
||
if !s.is_empty() && !s.ends_with(' ') && !s.ends_with('(') {
|
||
s.push(' ');
|
||
}
|
||
s.push_str(&self.entry);
|
||
}
|
||
self.expression = s;
|
||
}
|
||
|
||
// --- internals ---
|
||
|
||
fn unary(&mut self, f: impl FnOnce(Value) -> Result<Value, CalcError>) {
|
||
if self.error.is_some() {
|
||
return;
|
||
}
|
||
let Ok(v) = self.current_value() else {
|
||
return;
|
||
};
|
||
match f(v) {
|
||
Ok(r) => {
|
||
if self.panel == StdPanel::Formula {
|
||
// Unary applies to current entry only.
|
||
self.set_entry_value(r);
|
||
self.typing = true;
|
||
self.formula_done = false;
|
||
self.sync_formula_expression();
|
||
} else {
|
||
self.expression.clear();
|
||
self.set_entry_value(r);
|
||
self.typing = false;
|
||
}
|
||
}
|
||
Err(e) => self.fail(e),
|
||
}
|
||
}
|
||
|
||
fn current_value(&self) -> Result<Value, CalcError> {
|
||
if !self.typing {
|
||
if let Some(v) = self.entry_value {
|
||
return Ok(v);
|
||
}
|
||
}
|
||
Value::from_entry(&self.entry)
|
||
}
|
||
|
||
fn set_entry_value(&mut self, v: Value) {
|
||
self.entry = v.format();
|
||
self.entry_value = Some(v);
|
||
self.error = None;
|
||
}
|
||
|
||
fn fail(&mut self, e: CalcError) {
|
||
self.error = Some(e);
|
||
self.pending = None;
|
||
self.op = None;
|
||
self.entry_value = None;
|
||
self.expression.clear();
|
||
self.formula.clear();
|
||
self.formula_done = false;
|
||
self.typing = false;
|
||
}
|
||
}
|
||
|
||
// --- expression parser (formula mode) ---
|
||
|
||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||
enum Tok {
|
||
Num, // placeholder — numbers carried separately
|
||
Op(Op),
|
||
LParen,
|
||
RParen,
|
||
}
|
||
|
||
fn eval_expression(src: &str) -> Result<Value, CalcError> {
|
||
let tokens = tokenize(src)?;
|
||
let mut idx = 0;
|
||
let value = parse_expr(&tokens, &mut idx)?;
|
||
if idx != tokens.len() {
|
||
return Err(CalcError::Invalid);
|
||
}
|
||
Ok(value)
|
||
}
|
||
|
||
fn tokenize(src: &str) -> Result<Vec<(Tok, Option<Value>)>, CalcError> {
|
||
let mut out = Vec::new();
|
||
let chars: Vec<char> = src.chars().collect();
|
||
let mut i = 0;
|
||
while i < chars.len() {
|
||
let c = chars[i];
|
||
if c.is_whitespace() {
|
||
i += 1;
|
||
continue;
|
||
}
|
||
match c {
|
||
'+' => {
|
||
out.push((Tok::Op(Op::Add), None));
|
||
i += 1;
|
||
}
|
||
'−' | '-' => {
|
||
out.push((Tok::Op(Op::Sub), None));
|
||
i += 1;
|
||
}
|
||
'×' | '*' => {
|
||
out.push((Tok::Op(Op::Mul), None));
|
||
i += 1;
|
||
}
|
||
'÷' | '/' => {
|
||
out.push((Tok::Op(Op::Div), None));
|
||
i += 1;
|
||
}
|
||
'(' => {
|
||
out.push((Tok::LParen, None));
|
||
i += 1;
|
||
}
|
||
')' => {
|
||
out.push((Tok::RParen, None));
|
||
i += 1;
|
||
}
|
||
'0'..='9' | '.' => {
|
||
let start = i;
|
||
i += 1;
|
||
while i < chars.len() && (chars[i].is_ascii_digit() || chars[i] == '.') {
|
||
i += 1;
|
||
}
|
||
// Optional decimal exponent: `1e-9`, `2.5E+3`.
|
||
if i < chars.len() && (chars[i] == 'e' || chars[i] == 'E') {
|
||
let mut j = i + 1;
|
||
if j < chars.len() && (chars[j] == '+' || chars[j] == '-') {
|
||
j += 1;
|
||
}
|
||
if j < chars.len() && chars[j].is_ascii_digit() {
|
||
i = j;
|
||
while i < chars.len() && chars[i].is_ascii_digit() {
|
||
i += 1;
|
||
}
|
||
}
|
||
}
|
||
let lit: String = chars[start..i].iter().collect();
|
||
let v = Value::from_entry(&lit)?;
|
||
out.push((Tok::Num, Some(v)));
|
||
}
|
||
_ => return Err(CalcError::Invalid),
|
||
}
|
||
}
|
||
Ok(out)
|
||
}
|
||
|
||
fn parse_expr(tokens: &[(Tok, Option<Value>)], idx: &mut usize) -> Result<Value, CalcError> {
|
||
let mut left = parse_term(tokens, idx)?;
|
||
while let Some((Tok::Op(op @ (Op::Add | Op::Sub)), _)) = tokens.get(*idx).copied() {
|
||
*idx += 1;
|
||
let right = parse_term(tokens, idx)?;
|
||
left = left.apply(op, right)?;
|
||
}
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_term(tokens: &[(Tok, Option<Value>)], idx: &mut usize) -> Result<Value, CalcError> {
|
||
let mut left = parse_unary(tokens, idx)?;
|
||
while let Some((Tok::Op(op @ (Op::Mul | Op::Div)), _)) = tokens.get(*idx).copied() {
|
||
*idx += 1;
|
||
let right = parse_unary(tokens, idx)?;
|
||
left = left.apply(op, right)?;
|
||
}
|
||
Ok(left)
|
||
}
|
||
|
||
fn parse_unary(tokens: &[(Tok, Option<Value>)], idx: &mut usize) -> Result<Value, CalcError> {
|
||
if let Some((Tok::Op(Op::Sub), _)) = tokens.get(*idx).copied() {
|
||
*idx += 1;
|
||
let v = parse_unary(tokens, idx)?;
|
||
return v.apply(Op::Mul, Value::Rat(Rational::from_i128(-1)));
|
||
}
|
||
if let Some((Tok::Op(Op::Add), _)) = tokens.get(*idx).copied() {
|
||
*idx += 1;
|
||
return parse_unary(tokens, idx);
|
||
}
|
||
parse_primary(tokens, idx)
|
||
}
|
||
|
||
fn parse_primary(tokens: &[(Tok, Option<Value>)], idx: &mut usize) -> Result<Value, CalcError> {
|
||
let Some((tok, val)) = tokens.get(*idx).copied() else {
|
||
return Err(CalcError::Invalid);
|
||
};
|
||
match tok {
|
||
Tok::Num => {
|
||
*idx += 1;
|
||
val.ok_or(CalcError::Invalid)
|
||
}
|
||
Tok::LParen => {
|
||
*idx += 1;
|
||
let v = parse_expr(tokens, idx)?;
|
||
match tokens.get(*idx).copied() {
|
||
Some((Tok::RParen, _)) => {
|
||
*idx += 1;
|
||
Ok(v)
|
||
}
|
||
_ => Err(CalcError::Invalid),
|
||
}
|
||
}
|
||
_ => Err(CalcError::Invalid),
|
||
}
|
||
}
|
||
|
||
// --- formatting / helpers ---
|
||
|
||
fn digit_count(s: &str) -> usize {
|
||
s.chars().filter(|c| c.is_ascii_digit()).count()
|
||
}
|
||
|
||
/// Significant digits (leading zeros don't count) — caps precision, not
|
||
/// magnitude, so `0.0000000000000001` (1e-16) can be typed.
|
||
fn significant_digits(s: &str) -> usize {
|
||
s.chars()
|
||
.filter(|c| c.is_ascii_digit())
|
||
.skip_while(|&c| c == '0')
|
||
.count()
|
||
}
|
||
|
||
fn gcd(mut a: u128, mut b: u128) -> u128 {
|
||
while b != 0 {
|
||
let t = b;
|
||
b = a % b;
|
||
a = t;
|
||
}
|
||
a
|
||
}
|
||
|
||
fn pow10(n: usize) -> Result<i128, CalcError> {
|
||
let mut r: i128 = 1;
|
||
for _ in 0..n {
|
||
r = r.checked_mul(10).ok_or(CalcError::Overflow)?;
|
||
}
|
||
Ok(r)
|
||
}
|
||
|
||
fn format_rational(r: Rational) -> String {
|
||
if r.num == 0 {
|
||
return "0".into();
|
||
}
|
||
if r.is_integer() {
|
||
return r.num.to_string();
|
||
}
|
||
// Exact terminating decimal if den's primes ⊆ {2,5}.
|
||
if let Some(s) = terminating_decimal(r) {
|
||
return s;
|
||
}
|
||
format_float(r.to_f64())
|
||
}
|
||
|
||
fn terminating_decimal(r: Rational) -> Option<String> {
|
||
// Terminating iff den = 2^a · 5^b. Digit count after the point is
|
||
// k = max(a, b); scale num so the denominator becomes exactly 10^k.
|
||
let mut den = r.den;
|
||
let (mut a, mut b) = (0u32, 0u32);
|
||
while den % 2 == 0 {
|
||
den /= 2;
|
||
a += 1;
|
||
}
|
||
while den % 5 == 0 {
|
||
den /= 5;
|
||
b += 1;
|
||
}
|
||
if den != 1 {
|
||
return None;
|
||
}
|
||
let k = a.max(b);
|
||
let mut n = r.num.abs();
|
||
for _ in 0..(k - a) {
|
||
n = n.checked_mul(2)?;
|
||
}
|
||
for _ in 0..(k - b) {
|
||
n = n.checked_mul(5)?;
|
||
}
|
||
let mut d: i128 = 1;
|
||
for _ in 0..k {
|
||
d = d.checked_mul(10)?;
|
||
}
|
||
let int_part = n / d;
|
||
let mut frac = (n % d).to_string();
|
||
while frac.len() < k as usize {
|
||
frac.insert(0, '0');
|
||
}
|
||
// trim trailing zeros
|
||
while frac.ends_with('0') {
|
||
frac.pop();
|
||
}
|
||
let body = if frac.is_empty() {
|
||
int_part.to_string()
|
||
} else {
|
||
format!("{int_part}.{frac}")
|
||
};
|
||
Some(if r.num < 0 { format!("-{body}") } else { body })
|
||
}
|
||
|
||
fn format_float(v: f64) -> String {
|
||
if !v.is_finite() || v == 0.0 {
|
||
return "0".into();
|
||
}
|
||
// Snap near-integers (guards any float path residue); never for |v| < 1,
|
||
// otherwise tiny results like 1e-16 collapse to `0`.
|
||
let r = v.round();
|
||
if r != 0.0 && (v - r).abs() < 1e-10 && v.abs() < 1e15 {
|
||
return format!("{}", r as i64);
|
||
}
|
||
// Very small / large magnitudes: scientific notation keeps the value
|
||
// visible and re-parseable (`Rational::parse` understands exponents).
|
||
if v.abs() < 1e-10 || v.abs() >= 1e16 {
|
||
return format!("{v:e}");
|
||
}
|
||
// Shortest representation that round-trips back to `v` exactly.
|
||
format!("{v}")
|
||
}
|
||
|
||
impl fmt::Display for Rational {
|
||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||
if self.den == 1 {
|
||
write!(f, "{}", self.num)
|
||
} else {
|
||
write!(f, "{}/{}", self.num, self.den)
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn basic_add() {
|
||
let mut c = Calculator::new();
|
||
c.input_digit('1');
|
||
c.input_digit('2');
|
||
c.set_op(Op::Add);
|
||
c.input_digit('3');
|
||
c.equals();
|
||
assert_eq!(c.display(), "15");
|
||
}
|
||
|
||
#[test]
|
||
fn one_third_times_three_standard() {
|
||
let mut c = Calculator::new();
|
||
c.input_digit('1');
|
||
c.set_op(Op::Div);
|
||
c.input_digit('3');
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('3');
|
||
c.equals();
|
||
assert_eq!(c.display(), "1");
|
||
}
|
||
|
||
#[test]
|
||
fn one_third_times_three_formula() {
|
||
let mut c = Calculator::new();
|
||
c.set_panel(StdPanel::Formula);
|
||
c.input_digit('1');
|
||
c.set_op(Op::Div);
|
||
c.input_digit('3');
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('3');
|
||
c.equals();
|
||
assert_eq!(c.display(), "1");
|
||
assert!(c.expression().contains('='));
|
||
}
|
||
|
||
#[test]
|
||
fn formula_precedence() {
|
||
let mut c = Calculator::new();
|
||
c.set_panel(StdPanel::Formula);
|
||
c.input_digit('1');
|
||
c.set_op(Op::Add);
|
||
c.input_digit('2');
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('3');
|
||
c.equals();
|
||
assert_eq!(c.display(), "7");
|
||
}
|
||
|
||
#[test]
|
||
fn formula_parens() {
|
||
let mut c = Calculator::new();
|
||
c.set_panel(StdPanel::Formula);
|
||
c.paren_open();
|
||
c.input_digit('1');
|
||
c.set_op(Op::Add);
|
||
c.input_digit('2');
|
||
c.paren_close();
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('3');
|
||
c.equals();
|
||
assert_eq!(c.display(), "9");
|
||
}
|
||
|
||
#[test]
|
||
fn div_by_zero() {
|
||
let mut c = Calculator::new();
|
||
c.input_digit('1');
|
||
c.set_op(Op::Div);
|
||
c.input_digit('0');
|
||
c.equals();
|
||
assert!(c.display().contains("zero"));
|
||
}
|
||
|
||
#[test]
|
||
fn rational_parse_decimal() {
|
||
let r = Rational::parse("0.5").unwrap();
|
||
assert_eq!(r, Rational::new(1, 2).unwrap());
|
||
let r = Rational::parse("1.25").unwrap();
|
||
assert_eq!(r, Rational::new(5, 4).unwrap());
|
||
}
|
||
|
||
// --- regression tests (rounding / formatting bugs) ---
|
||
|
||
#[test]
|
||
fn quarter_and_eighth_display() {
|
||
// terminating_decimal scaled the fraction wrong: 1/4 displayed as "0.5".
|
||
let mut c = Calculator::new();
|
||
c.input_digit('1');
|
||
c.set_op(Op::Div);
|
||
c.input_digit('4');
|
||
c.equals();
|
||
assert_eq!(c.display(), "0.25");
|
||
|
||
c.clear_all();
|
||
c.input_digit('1');
|
||
c.set_op(Op::Div);
|
||
c.input_digit('8');
|
||
c.equals();
|
||
assert_eq!(c.display(), "0.125");
|
||
}
|
||
|
||
#[test]
|
||
fn five_hundredths_display() {
|
||
// 0.05 must survive exact formatting (was displayed as "0.1").
|
||
let mut c = Calculator::new();
|
||
c.input_digit('0');
|
||
c.input_dot();
|
||
c.input_digit('0');
|
||
c.input_digit('5'); // 0.05
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('1');
|
||
c.equals();
|
||
assert_eq!(c.display(), "0.05");
|
||
}
|
||
|
||
#[test]
|
||
fn tiny_reciprocal_not_zero() {
|
||
// 1/9999999999999999 ≈ 1e-16 was snapped to "0" by format_float.
|
||
let mut c = Calculator::new();
|
||
for d in "9999999999999999".chars() {
|
||
c.input_digit(d);
|
||
}
|
||
c.reciprocal();
|
||
let disp = c.display();
|
||
assert!(disp != "0", "tiny reciprocal must not display as 0, got {disp}");
|
||
}
|
||
|
||
#[test]
|
||
fn tiny_result_reusable_standard() {
|
||
// Float result in scientific notation must be re-parsable as operand.
|
||
let mut c = Calculator::new();
|
||
for d in "9999999999999999".chars() {
|
||
c.input_digit(d);
|
||
}
|
||
c.reciprocal();
|
||
c.set_op(Op::Mul);
|
||
c.input_digit('2');
|
||
c.equals();
|
||
let disp = c.display();
|
||
assert!(disp != "0" && disp != "Invalid input", "got {disp}");
|
||
}
|
||
|
||
#[test]
|
||
fn sqrt_square_roundtrip_tiny() {
|
||
// √(1e-30) = 1e-15 was snapped to 0 by Value::from_f64.
|
||
let mut c = Calculator::new();
|
||
c.input_dot(); // "0."
|
||
for _ in 0..14 {
|
||
c.input_digit('0');
|
||
}
|
||
c.input_digit('1'); // 0.000000000000001 = 1e-15
|
||
c.square();
|
||
c.sqrt();
|
||
let disp = c.display();
|
||
assert!(disp != "0", "sqrt(1e-30) must not display as 0, got {disp}");
|
||
}
|
||
|
||
#[test]
|
||
fn rational_parse_exponent() {
|
||
// Scientific-notation entries must parse to exact fractions.
|
||
let r = Rational::parse("1e-15").unwrap();
|
||
assert_eq!(r, Rational::new(1, 1_000_000_000_000_000).unwrap());
|
||
let r = Rational::parse("1.5e3").unwrap();
|
||
assert_eq!(r, Rational::new(1500, 1).unwrap());
|
||
let r = Rational::parse("2.5e-2").unwrap();
|
||
assert_eq!(r, Rational::new(1, 40).unwrap());
|
||
let r = Rational::parse("-1E+3").unwrap();
|
||
assert_eq!(r, Rational::new(-1000, 1).unwrap());
|
||
assert!(Rational::parse("1e2e3").is_err());
|
||
assert!(Rational::parse("1e").is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn can_type_one_e_minus_16() {
|
||
// Leading zeros must not eat the 16-significant-digit budget.
|
||
let mut c = Calculator::new();
|
||
c.input_dot();
|
||
for _ in 0..15 {
|
||
c.input_digit('0');
|
||
}
|
||
c.input_digit('1');
|
||
assert_eq!(c.display(), "0.0000000000000001");
|
||
}
|
||
}
|