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;
pub fn lex_cmp<V: Var>(a: &Mono<V>, b: &Mono<V>) -> 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<V: Var, U: Into<Mono<V>>> FromIterator<(i32, U)> for Poly<V> {
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct Mono<V: Var> {
pub term: Vec<(V, u32)>,
pub vars: Vec<(V, u32)>,
}
impl<V: Var> Mono<V> {
pub fn contains(&self, other: &Mono<V>) -> 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<V: Var> Mono<V> {
/// Returns the lcm of self and other (element-wise max of exponents).
pub fn lcm(&self, other: &Mono<V>) -> Mono<V> {
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<V: Var> Mono<V> {
}
}
Mono { term: result }
Mono { vars: result }
}
/// Divides self by other. Assumes `self.contains(other)`.
pub fn div(self, other: &Mono<V>) -> Mono<V> {
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<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> {
fn from_iter<T: IntoIterator<Item = (U, u32)>>(iter: T) -> Self {
let mut term = iter
let mut vars = iter
.into_iter()
.map(|(t, pow)| (t.into(), pow))
.collect::<Vec<(V, u32)>>();
term.sort();
vars.sort();
// Check duplicate variables
assert!(
(term[..])
(vars[..])
.windows(2)
.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!(
fmt,
"{}",
self.term
self.vars
.iter()
.map(|(t, p)| match p {
1 => format!("{t}"),

20
src/poly/ops.rs
View File

@@ -24,31 +24,31 @@ impl<V: Var> Mul for Mono<V> {
type Output = Self;
fn mul(self, other: Mono<V>) -> 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<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)
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);
}
@@ -110,7 +110,7 @@ fn test_lex_cmp() {
let xy: Mono<StaticVar> = [("x", 1), ("y", 1)].into();
let y2: Mono<StaticVar> = [("y", 2)].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)
assert_eq!(lex_cmp(&x2, &xy), Ordering::Greater);
@@ -144,7 +144,7 @@ fn test_mono_div() {
// x / x = 1
let a: 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]
@@ -210,7 +210,7 @@ fn test_s_poly() {
fn make_const_poly(c: i32) -> Poly<StaticVar> {
Poly {
mono: [(Mono { term: vec![] }, c)].into_iter().collect(),
mono: [(Mono { vars: vec![] }, c)].into_iter().collect(),
}
}