add incompatibility propagation to matrix

src/flowtable.rs

@@ -86,12 +86,11 @@ impl FlowTable {
             if left.output != right.output {
                 matrix.set_incompatible(first_row, second_row)
             } else {
-                if left.output.is_dont_care() || right.output.is_dont_care() ||
+                if left.to.is_dont_care() || right.to.is_dont_care() {
-                   left.to.is_dont_care() || right.to.is_dont_care() {
                     continue;
                 }
 
-                if left.output.unwrap() == left.output.unwrap() && left.to.unwrap() != right.to.unwrap() {
+                if left.to.unwrap() != right.to.unwrap() {
                     matrix.add_pair(first_row, second_row, (left.to.unwrap(), right.to.unwrap()))
                 }
             }
@@ -107,7 +106,8 @@ impl FlowTable {
             }
         }
         
-        dbg!(matrix);
+        let c_list = matrix.to_c_list();
+        matrix = dbg!(matrix);
         todo!()
     }
 }
@@ -132,6 +132,10 @@ impl Display for FlowTable {
                 write!(f, "| {},{} ", self.entries[state * self.num_inputs + i].to, self.entries[state * self.num_inputs + i].output)?;
             }
             writeln!(f)?;
+
+            if state == self.num_states - 1 {
+                break;
+            }
             
             write!(f, "-----+")?;
             for _ in 0..self.num_inputs {

src/main.rs

@@ -28,7 +28,7 @@ fn main() {
 
     flowtable.set_entry(4, 0, FlowTableValue::DontCare, FlowTableValue::DontCare);
     flowtable.set_entry(4, 1, FlowTableValue::DontCare, FlowTableValue::DontCare);
-    flowtable.set_entry(4, 2, FlowTableValue::Value(1), FlowTableValue::Value(1));
+    flowtable.set_entry(4, 2, FlowTableValue::Value(0), FlowTableValue::Value(1));
     flowtable.set_entry(4, 3, FlowTableValue::DontCare, FlowTableValue::DontCare);
 
     println!("original:");

src/statematrix.rs

@@ -1,3 +1,7 @@
+use std::thread::current;
+
+use crate::flowtable::FlowTableValue;
+
 #[derive(Debug, Clone)]
 enum Entry {
     Incompatible,
@@ -29,9 +33,15 @@ impl StateMatrix {
     pub fn add_pair(&mut self, first: usize, second: usize, pair: (usize, usize)) {
         let index = second * (second - 1) / 2 + first;
         
+        let ordered_pair = if pair.0 > pair.1 {(pair.1, pair.0)} else {pair};
+
         match &mut self.entries[index] {
             Entry::Implications(pairs) => {
-                pairs.push(pair);
+                if pairs.contains(&ordered_pair) {
+                    return;
+                }
+
+                pairs.push(ordered_pair);
                 return;
             },
 
@@ -46,4 +56,54 @@ impl StateMatrix {
 
         self.entries[index] = Entry::Incompatible;
     }
+
+    fn propagate_incompatibility(&mut self, pair: (usize, usize)) {
+        self.entries[pair.1 * (pair.1 - 1) / 2 + pair.0] = Entry::Incompatible; 
+
+        let mut incompatible_pairs: Vec<(usize, usize)> = vec![];        
+
+        let mut current_pair = (0, 1);
+        for entry in &self.entries {
+            match entry {
+                Entry::Incompatible => {},
+                Entry::Implications(pairs) => {
+                    if pairs.iter().find(|&&x| x == pair).is_some() {
+                        incompatible_pairs.push(current_pair);
+                    }
+                }
+            }
+
+            current_pair.0 += 1;
+            if current_pair.0 == current_pair.1 {
+                current_pair.1 += 1;
+                current_pair.0 = 0;
+            }
+        }
+
+        incompatible_pairs.iter().for_each(|&incompatible_pair| self.propagate_incompatibility(incompatible_pair));
+    }
+
+    fn add_incompatible_states(&mut self) {
+        let mut incompatible_pairs: Vec<(usize, usize)> = vec![];
+
+        let mut current_pair = (0, 1);
+        for entry in &self.entries {
+            match entry {
+                Entry::Incompatible => incompatible_pairs.push(current_pair),
+                _ => {}
+            };
+
+            current_pair.0 += 1;
+            if current_pair.0 == current_pair.1 {
+                current_pair.1 += 1;
+                current_pair.0 = 0;
+            }
+        }
+
+        incompatible_pairs.iter().for_each(|&pair| self.propagate_incompatibility(pair));
+    }
+
+    pub fn to_c_list(&mut self) {
+        self.add_incompatible_states();
+    }
 }