public Dfa(AutomataState startState) { _startState = startState; _transitions = new Dictionary<AutomataState, Dictionary<char, AutomataState>>(); _defaults = new Dictionary<AutomataState, AutomataState>(); _finalStates = new List<AutomataState>(); }
public char FindNextEdge(AutomataState s, char x) { Dictionary<char, AutomataState> set; AutomataState automataState; if (x == '\0') x = '\u0001'; x = (char)(x + 1); if (s == null || !_transitions.TryGetValue(s, out set)) set = new Dictionary<char, AutomataState>(); if (set.TryGetValue(x, out automataState) || (s != null && _defaults.TryGetValue(s, out automataState))) return x; List<char> orderedSet = set.Keys.OrderBy(y => y).ToList(); if (orderedSet.Count == 0) return '\0'; if (x < orderedSet[0]) return orderedSet[0]; if (x > orderedSet[orderedSet.Count - 1]) return '\0'; //where would x go in the sorted list? int j = 1 + orderedSet.TakeWhile(item => x < item).Count(); return orderedSet[j]; }
public void Add_AddingSameInputTwice_ThrowsException() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); int inputToSelf = 1; q1.Add(inputToSelf, q1); q1.Add(inputToSelf, q1); }
public void Add_AddingSameInputTwice_ThrowsException() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); int inputToSelf = 1; q1.Add(inputToSelf, q1); Assert.Throws<ArgumentException>(() => q1.Add(inputToSelf, q1)); }
public void Transit_UnknownInput_ReturnSelf() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); int unknownInput = -1; IAutomataState<int> transitedState = q1.Transit(unknownInput); Assert.That(transitedState, Is.SameAs(q1)); }
public void Transit_InputToSelf_ReturnSelf() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); int knownInput = 1; q1.Add(knownInput, q1); IAutomataState<int> transitedState = q1.Transit(knownInput); Assert.That(transitedState, Is.SameAs(q1)); }
public void NfaCanAddValidFinalState() { Tuple <int, int> final = Tuple.Create(1, 0); _nfa.AddFinalState(final); AutomataState expected = new AutomataState(final); Assert.AreEqual(expected, _nfa.FinalStates); }
public void Transit_InputToSecondState_ReturnSecondState() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); AutomataState<int> q2 = new AutomataState<int>("Q2", true); int inputToSecondState = 1; q1.Add(inputToSecondState, q2); IAutomataState<int> transitedState = q1.Transit(inputToSecondState); Assert.That(transitedState, Is.SameAs(q2)); }
public void Add_SingleElement_CurrentStateChanged() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> state = new AutomataState<int>("Root", true); automata.Add(state); Assert.That(automata.CurrentState, Is.SameAs(state)); }
public void GetEnumerator_SingleTransition_EnumeratesTransition() { AutomataState<int> state = new AutomataState<int>("Root", true); AutomataState<int> state1 = new AutomataState<int>("State1", true); state.Add(1, state1); Dictionary<int, IAutomataState<int>> exceptedEnumeration = new Dictionary<int, IAutomataState<int>>() { {1, state1} }; Assert.IsTrue(state.SequenceEqual(exceptedEnumeration)); }
public void AddTransition(AutomataState src, char input, AutomataState dest) { Dictionary<char, AutomataState> set; if (_transitions.TryGetValue(src, out set)) { if (set.ContainsKey(input)) set[input] = dest; else set.Add(input, dest); } else { set = new Dictionary<char, AutomataState> {{input, dest}}; _transitions.Add(src, set); } }
public void Add_FewElements_RootIsFirst() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> root = new AutomataState<int>("Root", true); AutomataState<int> state1 = new AutomataState<int>("State1", true); AutomataState<int> state2 = new AutomataState<int>("State2", true); automata.Add(root); automata.Add(state1); automata.Add(state2); Assert.That(automata.Root, Is.SameAs(root)); }
public void Reset_TwoStatesSingleInput_Root() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> valid = new AutomataState<int>("Valid", true); AutomataState<int> invalid = new AutomataState<int>("Invalid", false); automata.Add(valid); automata.Add(invalid); valid.Add(3, invalid); valid.Add(4, valid); automata.Read(3); automata.Reset(); Assert.That(automata.CurrentState, Is.SameAs(valid)); }
private AutomataState _FindNextState(AutomataState src, char input) { AutomataState nextState; if(_transitions.ContainsKey(src)) { Dictionary<char, AutomataState> stateTransitions = _transitions[src]; if (stateTransitions.TryGetValue(input, out nextState)) return nextState; if (_defaults.TryGetValue(src, out nextState)) return nextState; return null; } if (_defaults.TryGetValue(src, out nextState)) return nextState; return null; }
public void SetDefaultTransition(AutomataState src, AutomataState dest) { if (_defaults.ContainsKey(src)) _defaults[src] = dest; else _defaults.Add(src, dest); }
public void Read_TwoStatesTwoInputs_FirstState() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> valid = new AutomataState<int>("Valid", true); AutomataState<int> invalid = new AutomataState<int>("Invalid", false); automata.Add(valid); automata.Add(invalid); valid.Add(3, invalid); invalid.Add(4, valid); automata.Read(3); automata.Read(4); Assert.That(automata.CurrentState, Is.SameAs(valid)); Assert.That(automata.IsValid, Is.EqualTo(true)); }
public void GetEnumerator_FewElements_ExpectedEnumeration() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> root = new AutomataState<int>("Root", true); AutomataState<int> state1 = new AutomataState<int>("State1", true); AutomataState<int> state2 = new AutomataState<int>("State2", true); automata.Add(root); automata.Add(state1); automata.Add(state2); HashSet<IAutomataState<int>> expectedEnumeration = new HashSet<IAutomataState<int>>() { root, state1, state2 }; Assert.IsTrue(expectedEnumeration.SetEquals(automata)); }
private IEnumerable<char> _GetInputs(AutomataState states) { HashSet<char> inputs = new HashSet<char>(); foreach (Tuple<int, int> state in states.State) { Dictionary<char, AutomataState> set; if (!_transitions.TryGetValue(state, out set)) continue; foreach (char key in set.Keys) inputs.Add(key); } return inputs; }
private AutomataState _Expand(AutomataState states) { List<Tuple<int, int>> frontier = new List<Tuple<int, int>>(); frontier.AddRange(states.State); while (frontier.Count > 0) { Tuple<int, int> state = frontier[frontier.Count - 1]; frontier.RemoveAt(frontier.Count - 1); Dictionary<char, AutomataState> set; if (_transitions.TryGetValue(state, out set)) { AutomataState innerSet; if (set.TryGetValue(Epsilon, out innerSet)) { IList<Tuple<int, int>> newStates = innerSet.State.Except(states.State).ToList(); frontier.AddRange(newStates); foreach (var entry in newStates) states.Add(entry); } } } return states; }
public void GetEnumerator_AddingFewTransition_EnumeratesTransition() { AutomataState<int> state = new AutomataState<int>("Root", true); AutomataState<int> state1 = new AutomataState<int>("State1", true); AutomataState<int> state2 = new AutomataState<int>("State2", true); AutomataState<int> state3 = new AutomataState<int>("State3", true); state.Add(1, state1); state.Add(2, state2); state.Add(3, state3); HashSet<KeyValuePair<int, IAutomataState<int>>> exceptedEnumeration = new HashSet<KeyValuePair<int, IAutomataState<int>>>() { new KeyValuePair<int, IAutomataState<int>>(1, state1), new KeyValuePair<int, IAutomataState<int>>(2, state2), new KeyValuePair<int, IAutomataState<int>>(3, state3) }; Assert.IsTrue(exceptedEnumeration.SetEquals(state)); }
public void GetEnumerator_NoTransitions_NoEnumeration() { AutomataState<int> state = new AutomataState<int>("Root", true); Assert.IsTrue(!state.Any()); }
public void Add_AddingNullState_ThrowsException() { AutomataState<int> q1 = new AutomataState<int>("Q1", true); Assert.Throws<ArgumentNullException>(() => q1.Add(1, null)); }
private bool _IsFinal(AutomataState state) { return _finalStates.Contains(state); }
public void AddFinalState(AutomataState states) { _finalStates.Add(states); }
private bool _IsFinal(AutomataState states) { return _finalStates.State.Intersect(states.State).Any(); }
public void Reset_SingleState_Root() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> valid = new AutomataState<int>("Valid", true); automata.Add(valid); automata.Reset(); Assert.That(automata.CurrentState, Is.SameAs(valid)); }
private AutomataState _NextState(AutomataState states, char input) { AutomataState deststates = new AutomataState(); foreach (Tuple<int, int> state in states.State) { Dictionary<char, AutomataState> stateTransitions; if (!_transitions.TryGetValue(state, out stateTransitions)) continue; AutomataState set; if (stateTransitions.TryGetValue(input, out set)) { foreach (var item in set.State) deststates.Add(item); } if (!stateTransitions.TryGetValue(Any, out set)) continue; foreach (var item in set.State) deststates.Add(item); } return _Expand(deststates); }
public void Read_SingleState_Self() { DeterministicAutomata<int> automata = new DeterministicAutomata<int>(); AutomataState<int> root = new AutomataState<int>("Root", true); automata.Add(root); automata.Read(3); Assert.That(automata.CurrentState, Is.SameAs(root)); Assert.That(automata.IsValid, Is.EqualTo(root.IsValid)); }
public bool HasDefaultTransition(AutomataState src, AutomataState dest) { return _defaults.ContainsKey(src) && _defaults[src].Equals(dest); }
public Nfa() { _startState = Tuple.Create(0, 0); _transitions = new Dictionary<Tuple<int, int>, Dictionary<char, AutomataState>>(); _finalStates = new AutomataState(); }
public bool HasTransition(AutomataState src, char input, AutomataState dest) { return _transitions.ContainsKey(src) && _transitions[src].ContainsKey(input) && _transitions[src][input].Equals(dest); }