add quotient circuit structure and improve fmt for polynomials

examples/quotient.rs

@@ -0,0 +1,21 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use circuit_cas::circuit::quotient::Quotient;
+use circuit_cas::poly::var::StaticVar;
+use circuit_cas::var;
+
+fn main() {
+    let x=var!("x");
+    let nx=var!("x\u{0304}");
+
+    let idem = vec![
+        1*(&x^2)-1*(&x^1),
+        1*(&nx^2)-1*(&nx^1),
+        1*((&x^1)*(&nx^1))-1*(&x^1),
+    ];
+
+    let mut quotient:Quotient<StaticVar>=idem.into_iter().collect();
+
+    println!("{quotient}");
+}

src/circuit/dag.rs

@@ -8,7 +8,7 @@ use crate::poly::var::Var;
 
 new_key_type! { pub struct NodeId; }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Node<V: Var> {
     Leaf(V),
     Sum(NodeId, NodeId),
@@ -26,11 +26,21 @@ impl<V: Var> Node<V> {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct Circuit<V: Var> {
     nodes: SlotMap<NodeId, Node<V>>,
     intern: HashMap<Node<V>, NodeId>,
 }
 
+impl<V:Var> Default for Circuit<V>{
+    fn default()->Self{
+        Circuit{
+            nodes:Default::default(),
+            intern:Default::default()
+        }
+    }
+}
+
 impl<V: Var> Circuit<V> {
     pub fn new() -> Self {
         Circuit {

src/circuit/quotient.rs

@@ -1 +1,28 @@
+use crate::poly::{flat::Poly,var::Var};
+use super::dag::Circuit;
+
+use itertools::Itertools;
+
+use std::fmt::{self,Display};
+
+#[derive(Clone, Debug)]
+pub struct Quotient<V:Var>{
+    basis: Vec<Poly<V>>,
+    circuit: Circuit<V>,
+}
+
+impl<V: Var> FromIterator<Poly<V>> for Quotient<V> {
+    fn from_iter<T: IntoIterator<Item = Poly<V>>>(iter: T) -> Self {
+        Quotient {
+            basis:iter.into_iter().collect(),
+            circuit:Default::default()
+        }
+    }
+}
+
+impl<V:Var> Display for Quotient<V>{
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(),fmt::Error>{
+        write!(fmt, "C/<{}>", self.basis.iter().map(|p| format!("{p}")).join(","))
+    }
+}
 

src/poly/fmt.rs

@@ -33,7 +33,11 @@ impl<V: Var> Display for Poly<V> {
                 "{}",
                 self.mono
                     .iter()
-                    .map(|(m, c)| format!("{}{}", c, m))
+                    .map(|(m, c)| match c{
+                        1=>format!("{}", m),
+                        -1=>format!("-{}", m),
+                        _=>format!("{}{}", c, m),
+                    })
                     .join(" + ")
             ),
         }