asteri/circuit-cas
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename Mono fields for better understanding

Browse Source
This commit is contained in:
asteri
2026-04-24 10:14:00 +02:00
parent 0d5fc8225d
commit 3a83340c8f
4 changed files with 34 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/poly/flat.rs
View File

@@ -4,8 +4,8 @@ use std::collections::HashMap;
use super::var::Var; use super::var::Var;
pub fn lex_cmp<V: Var>(a: &Mono<V>, b: &Mono<V>) -> Ordering { pub fn lex_cmp<V: Var>(a: &Mono<V>, b: &Mono<V>) -> Ordering {
let mut a_it = a.term.iter().peekable(); let mut a_it = a.vars.iter().peekable();
let mut b_it = b.term.iter().peekable(); let mut b_it = b.vars.iter().peekable();
loop { loop {
match (a_it.peek(), b_it.peek()) { match (a_it.peek(), b_it.peek()) {
@@ -95,20 +95,20 @@ impl<V: Var, U: Into<Mono<V>>> FromIterator<(i32, U)> for Poly<V> {
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)] #[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Mono<V: Var> { pub struct Mono<V: Var> {
pub term: Vec<(V, u32)>, pub vars: Vec<(V, u32)>,
} }
impl<V: Var> Mono<V> { impl<V: Var> Mono<V> {
pub fn contains(&self, other: &Mono<V>) -> bool { pub fn contains(&self, other: &Mono<V>) -> bool {
let mut self_it = self.term.iter().peekable(); let mut self_it = self.vars.iter().peekable();
let mut other_it = other.term.iter().peekable(); let mut other_it = other.vars.iter().peekable();
while let Some((o_term, o_exp)) = other_it.peek() { while let Some((o_var, o_exp)) = other_it.peek() {
if let Some((s_term, s_exp)) = self_it.peek() { if let Some((s_var, s_exp)) = self_it.peek() {
if s_term < o_term { if s_var < o_var {
self_it.next(); self_it.next();
continue; continue;
} else if s_term > o_term { } else if s_var > o_var {
return false; return false;
} else if o_exp <= s_exp { } else if o_exp <= s_exp {
self_it.next(); self_it.next();
@@ -126,8 +126,8 @@ impl<V: Var> Mono<V> {
/// Returns the lcm of self and other (element-wise max of exponents). /// Returns the lcm of self and other (element-wise max of exponents).
pub fn lcm(&self, other: &Mono<V>) -> Mono<V> { pub fn lcm(&self, other: &Mono<V>) -> Mono<V> {
let mut self_it = self.term.iter().peekable(); let mut self_it = self.vars.iter().peekable();
let mut other_it = other.term.iter().peekable(); let mut other_it = other.vars.iter().peekable();
let mut result: Vec<(V, u32)> = vec![]; let mut result: Vec<(V, u32)> = vec![];
loop { loop {
@@ -149,13 +149,13 @@ impl<V: Var> Mono<V> {
} }
} }
Mono { term: result } Mono { vars: result }
} }
/// Divides self by other. Assumes `self.contains(other)`. /// Divides self by other. Assumes `self.contains(other)`.
pub fn div(self, other: &Mono<V>) -> Mono<V> { pub fn div(self, other: &Mono<V>) -> Mono<V> {
let mut self_it = self.term.into_iter().peekable(); let mut self_it = self.vars.into_iter().peekable();
let mut other_it = other.term.iter().peekable(); let mut other_it = other.vars.iter().peekable();
let mut result: Vec<(V, u32)> = vec![]; let mut result: Vec<(V, u32)> = vec![];
loop { loop {
@@ -179,7 +179,7 @@ impl<V: Var> Mono<V> {
} }
} }
Mono { term: result } Mono { vars: result }
} }
} }
@@ -194,19 +194,19 @@ where
impl<V: Var, U: Into<V>> FromIterator<(U, u32)> for Mono<V> { impl<V: Var, U: Into<V>> FromIterator<(U, u32)> for Mono<V> {
fn from_iter<T: IntoIterator<Item = (U, u32)>>(iter: T) -> Self { fn from_iter<T: IntoIterator<Item = (U, u32)>>(iter: T) -> Self {
let mut term = iter let mut vars = iter
.into_iter() .into_iter()
.map(|(t, pow)| (t.into(), pow)) .map(|(t, pow)| (t.into(), pow))
.collect::<Vec<(V, u32)>>(); .collect::<Vec<(V, u32)>>();
term.sort(); vars.sort();
// Check duplicate variables // Check duplicate variables
assert!( assert!(
(term[..]) (vars[..])
.windows(2) .windows(2)
.all(|window| window[0].0 != window[1].0) .all(|window| window[0].0 != window[1].0)
); );
Mono { term } Mono { vars }
} }
} }

2
src/poly/fmt.rs
View File

@@ -64,7 +64,7 @@ impl<V: Var> Display for Mono<V> {
write!( write!(
fmt, fmt,
"{}", "{}",
self.term self.vars
.iter() .iter()
.map(|(t, p)| match p { .map(|(t, p)| match p {
1 => format!("{t}"), 1 => format!("{t}"),

20
src/poly/ops.rs
View File

@@ -24,31 +24,31 @@ impl<V: Var> Mul for Mono<V> {
type Output = Self; type Output = Self;
fn mul(self, other: Mono<V>) -> Self::Output { fn mul(self, other: Mono<V>) -> Self::Output {
let mut a_term = self.term.into_iter().peekable(); let mut a_vars = self.vars.into_iter().peekable();
let mut b_term = other.term.into_iter().peekable(); let mut b_vars = other.vars.into_iter().peekable();
let mut result: Vec<(V, u32)> = Default::default(); let mut result: Vec<(V, u32)> = Default::default();
loop { loop {
match (a_term.peek(), b_term.peek()) { match (a_vars.peek(), b_vars.peek()) {
(Some((a_var, _)), Some((b_var, _))) => { (Some((a_var, _)), Some((b_var, _))) => {
if a_var < 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 { } else if a_var > b_var {
result.push(b_term.next().unwrap()); result.push(b_vars.next().unwrap());
} else { } else {
let (var, a_exp) = a_term.next().unwrap(); let (var, a_exp) = a_vars.next().unwrap();
let (_, b_exp) = b_term.next().unwrap(); let (_, b_exp) = b_vars.next().unwrap();
result.push((var, a_exp + b_exp)); result.push((var, a_exp + b_exp));
} }
} }
(Some(a), None) => { (Some(a), None) => {
result.push(a.clone()); result.push(a.clone());
a_term.next(); a_vars.next();
} }
(None, Some(b)) => { (None, Some(b)) => {
result.push(b.clone()); result.push(b.clone());
b_term.next(); b_vars.next();
} }
(None, None) => { (None, None) => {
break; break;
@@ -56,7 +56,7 @@ impl<V: Var> Mul for Mono<V> {
} }
} }
Mono { term: result } Mono { vars: result }
} }
} }

8
src/poly/tests.rs
View File

@@ -57,7 +57,7 @@ fn test_mono_mul() {
// Multiply by constant monomial (empty term vec = 1) // Multiply by constant monomial (empty term vec = 1)
let a: Mono<StaticVar> = [("x", 4)].into(); let a: Mono<StaticVar> = [("x", 4)].into();
let one: Mono<StaticVar> = Mono { term: vec![] }; let one: Mono<StaticVar> = Mono { vars: vec![] };
assert_eq!(a.clone() * one, a); assert_eq!(a.clone() * one, a);
} }
@@ -110,7 +110,7 @@ fn test_lex_cmp() {
let xy: Mono<StaticVar> = [("x", 1), ("y", 1)].into(); let xy: Mono<StaticVar> = [("x", 1), ("y", 1)].into();
let y2: Mono<StaticVar> = [("y", 2)].into(); let y2: Mono<StaticVar> = [("y", 2)].into();
let x: Mono<StaticVar> = [("x", 1)].into(); let x: Mono<StaticVar> = [("x", 1)].into();
let one: Mono<StaticVar> = Mono { term: vec![] }; let one: Mono<StaticVar> = Mono { vars: vec![] };
// x² > xy (x exponent 2 vs 1) // x² > xy (x exponent 2 vs 1)
assert_eq!(lex_cmp(&x2, &xy), Ordering::Greater); assert_eq!(lex_cmp(&x2, &xy), Ordering::Greater);
@@ -144,7 +144,7 @@ fn test_mono_div() {
// x / x = 1 // x / x = 1
let a: Mono<StaticVar> = [("x", 1)].into(); let a: Mono<StaticVar> = [("x", 1)].into();
let b: Mono<StaticVar> = [("x", 1)].into(); let b: Mono<StaticVar> = [("x", 1)].into();
assert_eq!(a.div(&b), Mono { term: vec![] }); assert_eq!(a.div(&b), Mono { vars: vec![] });
} }
#[test] #[test]
@@ -210,7 +210,7 @@ fn test_s_poly() {
fn make_const_poly(c: i32) -> Poly<StaticVar> { fn make_const_poly(c: i32) -> Poly<StaticVar> {
Poly { Poly {
mono: [(Mono { term: vec![] }, c)].into_iter().collect(), mono: [(Mono { vars: vec![] }, c)].into_iter().collect(),
} }
} }