use crate::ast::Factor;
#[derive(Debug, Clone)]
pub(crate) struct Term {
pub factors: Vec<Factor>,
}
impl PartialEq for Term {
fn eq(&self, other: &Self) -> bool {
if self.factors.len() != other.factors.len() {
return false;
}
let mut a: Vec<String> = self.factors.iter().map(Factor::key).collect();
let mut b: Vec<String> = other.factors.iter().map(Factor::key).collect();
a.sort();
b.sort();
a == b
}
}
impl Eq for Term {}
impl Term {
pub fn intercept() -> Self {
Term { factors: vec![] }
}
pub fn from_factor(f: Factor) -> Self {
Term { factors: vec![f] }
}
pub fn is_intercept(&self) -> bool {
self.factors.is_empty()
}
pub fn interact(&self, other: &Term) -> Term {
let mut factors = self.factors.clone();
for f in &other.factors {
if !factors.iter().any(|x| x.key() == f.key()) {
factors.push(f.clone());
}
}
Term { factors }
}
}
#[derive(Debug, Clone)]
pub(crate) struct TermList {
pub intercept: bool,
pub terms: Vec<Term>,
}
impl TermList {
pub fn with_intercept() -> Self {
TermList {
intercept: true,
terms: vec![],
}
}
pub fn set_intercept(&mut self, on: bool) {
self.intercept = on;
}
pub fn add(&mut self, t: Term) {
if t.is_intercept() {
self.intercept = true;
return;
}
if !self.terms.iter().any(|x| x == &t) {
self.terms.push(t);
}
}
pub fn remove(&mut self, t: &Term) {
if t.is_intercept() {
self.intercept = false;
return;
}
self.terms.retain(|x| x != t);
}
}