nfa to dfa

Author: Robert Durfee

src/dfa.rs

@@ -1,57 +1,57 @@
-use std::collections::{HashMap, HashSet};
-use std::hash::Hash;
+use std::collections::{BTreeMap, BTreeSet};
 
 use crate::nfa::NFA;
 
+#[derive(Debug, PartialEq)]
 pub(crate) struct DFA<S, E> {
     initial: S,
-    transitions: HashMap<S, HashMap<E, S>>,
-    finals: HashSet<S>,
+    transitions: BTreeMap<S, BTreeMap<E, S>>,
+    finals: BTreeSet<S>,
 }
 
 impl<S, E> DFA<S, E>
 where
-    S: Copy + Eq + Hash,
-    E: Copy + Eq + Hash
+    S: Copy + Ord,
+    E: Copy + Ord
 {
     fn new(initial: S) -> Self {
         Self {
             initial,
-            transitions: map![initial => HashMap::new()],
-            finals: HashSet::new(),
+            transitions: map![initial => BTreeMap::new()],
+            finals: BTreeSet::new(),
         }
     }
 
     fn insert(&mut self, state: S) {
         if !self.transitions.contains_key(&state) {
-            self.transitions.insert(state, HashMap::new());
+            self.transitions.insert(state, BTreeMap::new());
         }
     }
 
     fn insert_transition(&mut self, start: S, event: E, end: S) {
         if !self.transitions.contains_key(&start) {
-            self.transitions.insert(start, HashMap::new());
+            self.transitions.insert(start, BTreeMap::new());
         }
         if !self.transitions.contains_key(&end) {
-            self.transitions.insert(end, HashMap::new());
+            self.transitions.insert(end, BTreeMap::new());
         }
         self.transitions.get_mut(&start).unwrap().insert(event, end);
     }
 
     fn insert_final(&mut self, state: S) {
         if !self.transitions.contains_key(&state) {
-            self.transitions.insert(state, HashMap::new());
+            self.transitions.insert(state, BTreeMap::new());
         }
         self.finals.insert(state);
     }
 }
 
-impl<S, E> Extend<(S, HashMap<E, S>)> for DFA<S, E>
+impl<S, E> Extend<(S, BTreeMap<E, S>)> for DFA<S, E>
 where 
-    S: Copy + Eq + Hash,
-    E: Copy + Eq + Hash
+    S: Copy + Ord,
+    E: Copy + Ord
 {
-    fn extend<T: IntoIterator<Item = (S, HashMap<E, S>)>>(&mut self, iter: T) {
+    fn extend<T: IntoIterator<Item = (S, BTreeMap<E, S>)>>(&mut self, iter: T) {
         for (start, transitions) in iter.into_iter() {
             for (event, end) in transitions.into_iter() {
                 self.insert_transition(start, event, end);
@@ -60,12 +60,160 @@ where
     }
 }
 
-impl<S, E> From<NFA<S, E>> for DFA<S, E> 
+impl<S, E> From<NFA<S, E>> for DFA<BTreeSet<S>, E> 
 where
-    S: Eq + Hash,
-    E: Eq + Hash
+    S: Clone + Ord,
+    E: Clone + Ord
 {
-    fn from(_nfa: NFA<S, E>) -> DFA<S, E> {
-        panic!("Not implemented")
+    fn from(nfa: NFA<S, E>) -> DFA<BTreeSet<S>, E> {
+        let mut start_sets = vec![set![nfa.initial().clone()]];
+        let mut transitions = BTreeMap::new();
+        let mut finals = BTreeSet::new();
+        while let Some(start_set) = start_sets.pop() {
+            transitions.insert(start_set.clone(), BTreeMap::new());
+            for start in &start_set {
+                for (event, end_set) in nfa.get(&start).unwrap().clone() {
+                    if !transitions.contains_key(&end_set) {
+                        start_sets.push(end_set.clone());
+                    }
+                    transitions.get_mut(&start_set).unwrap().insert(event, end_set);
+                }
+                if nfa.is_final(&start) {
+                    finals.insert(start_set.clone());
+                }
+            }
+        }
+        DFA {
+            initial: set![nfa.initial().clone()],
+            transitions,
+            finals
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::nfa::ENFA;
+    use crate::dfa::DFA;
+    use crate::re::RE;
+
+    #[test]
+    fn test_1() {
+        let expected = DFA {
+            initial: set![0u128],
+            transitions: map![
+                set![0u128] => map![
+                    None => set![1u128]
+                ],
+                set![1u128] => map![]
+            ],
+            finals: set![set![1u128]],
+        };
+        let actual = DFA::from(ENFA::from(RE::Epsilon));
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_2() {
+        let expected = DFA {
+            initial: set![0u128],
+            transitions: map![
+                set![0u128] => map![
+                    Some('A') => set![1u128]
+                ],
+                set![1u128] => map![]
+            ],
+            finals: set![set![1u128]],
+        };
+        let actual = DFA::from(ENFA::from(RE::Symbol { symbol: 'A' }));
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_3() {
+        let expected = DFA {
+            initial: set![0u128],
+            transitions: map![
+                set![0u128] => map![
+                    None => set![2u128, 4u128]
+                ],
+                set![2u128, 4u128] => map![
+                    None => set![3u128],
+                    Some('A') => set![5u128]
+                ],
+                set![3u128] => map![
+                    None => set![1u128]
+                ],
+                set![5u128] => map![
+                    None => set![1u128]
+                ],
+                set![1u128] => map![]
+            ],
+            finals: set![set![1u128]],
+        };
+        let actual = DFA::from(ENFA::from(RE::Alternation {
+            res: vec![
+                RE::Epsilon,
+                RE::Symbol { symbol: 'A' },
+            ],
+        }));
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_4() {
+        let expected = DFA {
+            initial: set![0u128],
+            transitions: map![
+                set![0u128] => map![
+                    None => set![2u128]
+                ],
+                set![2u128] => map![
+                    Some('A') => set![3u128]
+                ],
+                set![3u128] => map![
+                    None => set![4u128]
+                ],
+                set![4u128] => map![
+                    None => set![5u128]
+                ],
+                set![5u128] => map![
+                    None => set![1u128]
+                ],
+                set![1u128] => map![]
+            ],
+            finals: set![set![1u128]],
+        };
+        let actual = DFA::from(ENFA::from(RE::Concatenation {
+            res: vec![
+                RE::Symbol { symbol: 'A' },
+                RE::Epsilon,
+            ],
+        }));
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_5() {
+        let expected = DFA {
+            initial: set![0u128],
+            transitions: map![
+                set![0u128] => map![
+                    None => set![2u128, 1u128]
+                ],
+                set![2u128, 1u128] => map![
+                    Some('A') => set![3u128]
+                ],
+                set![3u128] => map![
+                    None => set![2u128, 1u128]
+                ]
+            ],
+            finals: set![set![2u128, 1u128]],
+        };
+        let actual = DFA::from(ENFA::from(RE::Repetition {
+            re: Box::new(RE::Symbol { symbol: 'A' }),
+        }));
+        assert_eq!(expected, actual);
     }
+
 }

src/nfa.rs

@@ -1,67 +1,84 @@
-use std::collections::{HashMap, HashSet};
-use std::hash::Hash;
+use std::collections::{BTreeMap, BTreeSet};
 
 use crate::util::IDGenerator;
 use crate::re::RE;
 
 #[derive(Debug, PartialEq)]
 pub(crate) struct NFA<S, E> 
 where
-    S: Eq + Hash,
-    E: Eq + Hash
+    S: Ord,
+    E: Ord
 { 
     initial: S,
-    transitions: HashMap<S, HashMap<E, HashSet<S>>>,
-    finals: HashSet<S>,
+    transitions: BTreeMap<S, BTreeMap<E, BTreeSet<S>>>,
+    finals: BTreeSet<S>,
 }
 
 impl<S, E> NFA<S, E>
 where
-    S: Copy + Eq + Hash,
-    E: Copy + Eq + Hash
+    S: Copy + Ord,
+    E: Copy + Ord
 {
     fn new(initial: S) -> Self {
         Self {
             initial,
-            transitions: map![initial => HashMap::new()],
-            finals: HashSet::new(),
+            transitions: map![initial => BTreeMap::new()],
+            finals: BTreeSet::new(),
         }
     }
 
     fn insert(&mut self, state: S) {
         if !self.transitions.contains_key(&state) {
-            self.transitions.insert(state, HashMap::new());
+            self.transitions.insert(state, BTreeMap::new());
         }
     }
 
     fn insert_transition(&mut self, start: S, event: E, end: S) {
         if !self.transitions.contains_key(&start) {
-            self.transitions.insert(start, HashMap::new());
+            self.transitions.insert(start, BTreeMap::new());
         }
         if !self.transitions.contains_key(&end) {
-            self.transitions.insert(end, HashMap::new());
+            self.transitions.insert(end, BTreeMap::new());
         }
         let start_transitions = self.transitions.get_mut(&start).unwrap();
         if !start_transitions.contains_key(&event) {
-            start_transitions.insert(event, HashSet::new());
+            start_transitions.insert(event, BTreeSet::new());
         }
         start_transitions.get_mut(&event).unwrap().insert(end);
     }
 
     fn insert_final(&mut self, state: S) {
         if !self.transitions.contains_key(&state) {
-            self.transitions.insert(state, HashMap::new());
+            self.transitions.insert(state, BTreeMap::new());
         }
         self.finals.insert(state);
     }
 }
 
-impl<S, E> Extend<(S, HashMap<E, HashSet<S>>)> for NFA<S, E>
+impl<S, E> NFA<S, E> 
+where
+    S: Ord,
+    E: Ord
+{
+    pub(crate) fn initial(&self) -> &S {
+        &self.initial
+    }
+
+    pub(crate) fn get(&self, state: &S) -> Option<&BTreeMap<E, BTreeSet<S>>> {
+        self.transitions.get(state)
+    }
+
+    pub(crate) fn is_final(&self, state: &S) -> bool {
+        self.finals.contains(state)
+    }
+}
+
+impl<S, E> Extend<(S, BTreeMap<E, BTreeSet<S>>)> for NFA<S, E>
 where 
-    S: Copy + Eq + Hash,
-    E: Copy + Eq + Hash
+    S: Copy + Ord,
+    E: Copy + Ord
 {
-    fn extend<T: IntoIterator<Item = (S, HashMap<E, HashSet<S>>)>>(&mut self, iter: T) {
+    fn extend<T: IntoIterator<Item = (S, BTreeMap<E, BTreeSet<S>>)>>(&mut self, iter: T) {
         for (start, transitions) in iter.into_iter() {
             for (event, ends) in transitions.into_iter() {
                 for end in ends.into_iter() {
@@ -72,7 +89,7 @@ where
     }
 }
 
-type ENFA<S, E> = NFA<S, Option<E>>;
+pub(crate) type ENFA<S, E> = NFA<S, Option<E>>;
 
 impl ENFA<u128, char> {
     fn _from(re: RE, ids: &mut IDGenerator) -> Self {

src/util.rs

@@ -18,23 +18,23 @@ impl IDGenerator {
 macro_rules! map {
     ($($x:expr => $y:expr),*) => {{
         #[allow(unused_mut)]
-        let mut temp_hash_map = std::collections::HashMap::new();
+        let mut temp_map = std::collections::BTreeMap::new();
         $(
-            temp_hash_map.insert($x, $y);
+            temp_map.insert($x, $y);
         )*
-        temp_hash_map
+        temp_map
     }}
 }
 
 #[macro_export]
 macro_rules! set {
     ($($x:expr),*) => {{
         #[allow(unused_mut)]
-        let mut temp_hash_set = std::collections::HashSet::new();
+        let mut temp_set = std::collections::BTreeSet::new();
         $(
-            temp_hash_set.insert($x);
+            temp_set.insert($x);
         )*
-        temp_hash_set
+        temp_set
     }}
 }