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));
}
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);
}
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 Dfa(AutomataState startState)
{
_startState = startState;
_transitions = new Dictionary <AutomataState, Dictionary <char, AutomataState> >();
_defaults = new Dictionary <AutomataState, AutomataState>();
_finalStates = new List <AutomataState>();
}
public void SetDefaultTransition(AutomataState src, AutomataState dest)
{
if (_defaults.ContainsKey(src))
{
_defaults[src] = dest;
}
else
{
_defaults.Add(src, dest);
}
}
public Dfa ConstructDfaUsingPowerSet()
{
Dfa dfa = new Dfa(StartState);
Stack <AutomataState> frontier = new Stack <AutomataState>();
frontier.Push(StartState);
HashSet <AutomataState> seen = new HashSet <AutomataState>();
while (frontier.Count > 0)
{
AutomataState state = frontier.Pop();
IEnumerable <char> inputs = _GetInputs(state);
foreach (char input in inputs)
{
if (input.Equals(Epsilon))
{
continue;
}
AutomataState nextState = _NextState(state, input);
if (!seen.Contains(nextState))
{
frontier.Push(nextState);
seen.Add(nextState);
if (_IsFinal(nextState))
{
dfa.AddFinalState(nextState);
}
}
if (input == Any)
{
if (!dfa.HasTransition(state, input, nextState))
{
dfa.SetDefaultTransition(state, nextState);
}
}
else
{
if (!dfa.HasDefaultTransition(state, nextState))
{
dfa.AddTransition(state, input, nextState);
}
}
}
}
return(dfa);
}
public string FindNextValidString(string input)
{
AutomataState state = _startState;
Stack <Tuple <string, AutomataState, char> > stack = new Stack <Tuple <string, AutomataState, char> >();
int i = 0;
foreach (char c in input)
{
stack.Push(Tuple.Create(input.Substring(0, i), state, c));
state = _FindNextState(state, c);
if (state == null)
{
break;
}
i++;
}
if (_IsFinal(state))
{
return(input);
}
while (stack.Count > 0)
{
Tuple <string, AutomataState, char> item = stack.Pop();
string path = item.Item1.TrimStart(System.IO.Path.GetInvalidFileNameChars());
AutomataState itemState = item.Item2;
char x = item.Item3;
x = FindNextEdge(itemState, x);
if (x != '\0')
{
path += x;
itemState = _FindNextState(itemState, x);
if (_IsFinal(itemState))
{
return(path);
}
stack.Push(Tuple.Create(path, itemState, '\u0001'));
}
}
return(null);
}
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);
}
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 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);
}
}
private bool _IsFinal(AutomataState states)
{
return(_finalStates.State.Intersect(states.State).Any());
}
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));
}
public bool HasDefaultTransition(AutomataState src, AutomataState dest)
{
return(_defaults.ContainsKey(src) && _defaults[src].Equals(dest));
}
public void AddFinalState(AutomataState states)
{
_finalStates.Add(states);
}
private bool _IsFinal(AutomataState state)
{
return(_finalStates.Contains(state));
}
