From 3a83340c8f03bfeaecd77da30fb6e0e7c00ccd2a Mon Sep 17 00:00:00 2001 From: asteri Date: Fri, 24 Apr 2026 10:14:00 +0200 Subject: [PATCH] rename Mono fields for better understanding --- src/poly/flat.rs | 38 +++++++++++++++++++------------------- src/poly/fmt.rs | 2 +- src/poly/ops.rs | 20 ++++++++++---------- src/poly/tests.rs | 8 ++++---- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/poly/flat.rs b/src/poly/flat.rs index 48516ed..78b783d 100644 --- a/src/poly/flat.rs +++ b/src/poly/flat.rs @@ -4,8 +4,8 @@ use std::collections::HashMap; use super::var::Var; pub fn lex_cmp(a: &Mono, b: &Mono) -> Ordering { - let mut a_it = a.term.iter().peekable(); - let mut b_it = b.term.iter().peekable(); + let mut a_it = a.vars.iter().peekable(); + let mut b_it = b.vars.iter().peekable(); loop { match (a_it.peek(), b_it.peek()) { @@ -95,20 +95,20 @@ impl>> FromIterator<(i32, U)> for Poly { #[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)] pub struct Mono { - pub term: Vec<(V, u32)>, + pub vars: Vec<(V, u32)>, } impl Mono { pub fn contains(&self, other: &Mono) -> bool { - let mut self_it = self.term.iter().peekable(); - let mut other_it = other.term.iter().peekable(); + let mut self_it = self.vars.iter().peekable(); + let mut other_it = other.vars.iter().peekable(); - while let Some((o_term, o_exp)) = other_it.peek() { - if let Some((s_term, s_exp)) = self_it.peek() { - if s_term < o_term { + while let Some((o_var, o_exp)) = other_it.peek() { + if let Some((s_var, s_exp)) = self_it.peek() { + if s_var < o_var { self_it.next(); continue; - } else if s_term > o_term { + } else if s_var > o_var { return false; } else if o_exp <= s_exp { self_it.next(); @@ -126,8 +126,8 @@ impl Mono { /// Returns the lcm of self and other (element-wise max of exponents). pub fn lcm(&self, other: &Mono) -> Mono { - let mut self_it = self.term.iter().peekable(); - let mut other_it = other.term.iter().peekable(); + let mut self_it = self.vars.iter().peekable(); + let mut other_it = other.vars.iter().peekable(); let mut result: Vec<(V, u32)> = vec![]; loop { @@ -149,13 +149,13 @@ impl Mono { } } - Mono { term: result } + Mono { vars: result } } /// Divides self by other. Assumes `self.contains(other)`. pub fn div(self, other: &Mono) -> Mono { - let mut self_it = self.term.into_iter().peekable(); - let mut other_it = other.term.iter().peekable(); + let mut self_it = self.vars.into_iter().peekable(); + let mut other_it = other.vars.iter().peekable(); let mut result: Vec<(V, u32)> = vec![]; loop { @@ -179,7 +179,7 @@ impl Mono { } } - Mono { term: result } + Mono { vars: result } } } @@ -194,19 +194,19 @@ where impl> FromIterator<(U, u32)> for Mono { fn from_iter>(iter: T) -> Self { - let mut term = iter + let mut vars = iter .into_iter() .map(|(t, pow)| (t.into(), pow)) .collect::>(); - term.sort(); + vars.sort(); // Check duplicate variables assert!( - (term[..]) + (vars[..]) .windows(2) .all(|window| window[0].0 != window[1].0) ); - Mono { term } + Mono { vars } } } diff --git a/src/poly/fmt.rs b/src/poly/fmt.rs index ab59df8..38c4f87 100644 --- a/src/poly/fmt.rs +++ b/src/poly/fmt.rs @@ -64,7 +64,7 @@ impl Display for Mono { write!( fmt, "{}", - self.term + self.vars .iter() .map(|(t, p)| match p { 1 => format!("{t}"), diff --git a/src/poly/ops.rs b/src/poly/ops.rs index 1bb186b..d7219a7 100644 --- a/src/poly/ops.rs +++ b/src/poly/ops.rs @@ -24,31 +24,31 @@ impl Mul for Mono { type Output = Self; fn mul(self, other: Mono) -> Self::Output { - let mut a_term = self.term.into_iter().peekable(); - let mut b_term = other.term.into_iter().peekable(); + let mut a_vars = self.vars.into_iter().peekable(); + let mut b_vars = other.vars.into_iter().peekable(); let mut result: Vec<(V, u32)> = Default::default(); loop { - match (a_term.peek(), b_term.peek()) { + match (a_vars.peek(), b_vars.peek()) { (Some((a_var, _)), Some((b_var, _))) => { if a_var < b_var { - result.push(a_term.next().unwrap()); + result.push(a_vars.next().unwrap()); } else if a_var > b_var { - result.push(b_term.next().unwrap()); + result.push(b_vars.next().unwrap()); } else { - let (var, a_exp) = a_term.next().unwrap(); - let (_, b_exp) = b_term.next().unwrap(); + let (var, a_exp) = a_vars.next().unwrap(); + let (_, b_exp) = b_vars.next().unwrap(); result.push((var, a_exp + b_exp)); } } (Some(a), None) => { result.push(a.clone()); - a_term.next(); + a_vars.next(); } (None, Some(b)) => { result.push(b.clone()); - b_term.next(); + b_vars.next(); } (None, None) => { break; @@ -56,7 +56,7 @@ impl Mul for Mono { } } - Mono { term: result } + Mono { vars: result } } } diff --git a/src/poly/tests.rs b/src/poly/tests.rs index d29c155..cae5cb7 100644 --- a/src/poly/tests.rs +++ b/src/poly/tests.rs @@ -57,7 +57,7 @@ fn test_mono_mul() { // Multiply by constant monomial (empty term vec = 1) let a: Mono = [("x", 4)].into(); - let one: Mono = Mono { term: vec![] }; + let one: Mono = Mono { vars: vec![] }; assert_eq!(a.clone() * one, a); } @@ -110,7 +110,7 @@ fn test_lex_cmp() { let xy: Mono = [("x", 1), ("y", 1)].into(); let y2: Mono = [("y", 2)].into(); let x: Mono = [("x", 1)].into(); - let one: Mono = Mono { term: vec![] }; + let one: Mono = Mono { vars: vec![] }; // x² > xy (x exponent 2 vs 1) assert_eq!(lex_cmp(&x2, &xy), Ordering::Greater); @@ -144,7 +144,7 @@ fn test_mono_div() { // x / x = 1 let a: Mono = [("x", 1)].into(); let b: Mono = [("x", 1)].into(); - assert_eq!(a.div(&b), Mono { term: vec![] }); + assert_eq!(a.div(&b), Mono { vars: vec![] }); } #[test] @@ -210,7 +210,7 @@ fn test_s_poly() { fn make_const_poly(c: i32) -> Poly { Poly { - mono: [(Mono { term: vec![] }, c)].into_iter().collect(), + mono: [(Mono { vars: vec![] }, c)].into_iter().collect(), } }