public void buildAll(string regExpr)
{
buildNonDeterministicFA(regExpr);
buildDeterminsticFA();
minimizeDeterministicFA();
_deterministicFA = _nonDeterministicFA.determine();
}
public FiniteAutomate buildIteration(FiniteAutomate fa)
{
FiniteAutomate iterFA = new FiniteAutomate();
int shift = iterFA.add(fa);
iterFA.InitState = iterFA.addState();
iterFA.addTransition(iterFA.InitState, fa.InitState + shift, ' ');
iterFA.FinStates.Add(iterFA.addState());
iterFA.addTransition(fa.FinStates.First() + shift, iterFA.FinStates.First(), ' ');
iterFA.addTransition(fa.FinStates.First() + shift, fa.InitState + shift, ' ');
iterFA.addTransition(iterFA.InitState, iterFA.FinStates.First(), ' ');
return iterFA;
}
private FiniteAutomate buildOr(FiniteAutomate fa1, FiniteAutomate fa2)
{
FiniteAutomate fa = new FiniteAutomate();
int shift1 = fa.add(fa1);
int shift2 = fa.add(fa2);
fa.InitState = fa.addState();
fa.addTransition(fa.InitState, fa1.InitState+shift1, ' '); // epsilon-transition
fa.addTransition(fa.InitState, fa2.InitState+shift2, ' ');
fa.FinStates.Add(fa.addState());
fa.addTransition(fa1.FinStates.First() + shift1, fa.FinStates.First(), ' ');
fa.addTransition(fa2.FinStates.First() + shift2, fa.FinStates.First(), ' ');
return fa;
}
private FiniteAutomate buildAnd(FiniteAutomate fa1, FiniteAutomate fa2)
{
FiniteAutomate fa = new FiniteAutomate();
int shift1 = fa.add(fa1);
int shift2 = fa.add(fa2);
fa.InitState = fa1.InitState + shift1;
fa.FinStates.Add(fa2.FinStates.First() + shift2);
List<int> statesToUnion = new List<int>();
statesToUnion.Add(fa1.FinStates.First() + shift1);
statesToUnion.Add(fa2.InitState + shift2);
fa.unionStates(statesToUnion);
return fa;
}
public int add(FiniteAutomate fa)
{
// copy states from other FA
int maxSt = 0;
if (_states.Count > 0)
maxSt = _states.Max()+1;
for (int i = 0; i < fa._states.Count; i++)
_states.Add(fa._states[i] + maxSt);
for (int i = 0; i < fa._transitions.Count; i++)
addTransition(fa._transitions[i].From + maxSt, fa._transitions[i].To + maxSt, fa._transitions[i].Label);
for (int i = 0; i < fa._labels.Count; i++)
addLabel(fa._labels[i]);
return maxSt;
}
public void minimizeDeterministicFA()
{
_minDeterministicFA = _deterministicFA.minimize();
}
public void buildNonDeterministicFA(string regExpr)
{
string postfixNotation = ExpressionTransformer.transformToPostfixNotation(regExpr);
BuilderFA builder = new TompsonBuilder();
_nonDeterministicFA = builder.build(postfixNotation);
}
public void buildDeterminsticFA()
{
_deterministicFA = _nonDeterministicFA.determine();
}
public Dispatcher()
{
_nonDeterministicFA = new FiniteAutomate();
_deterministicFA = new FiniteAutomate();
_minDeterministicFA = new FiniteAutomate();
}
public FiniteAutomate minimize()
{
FiniteAutomate minFA = new FiniteAutomate();
List<int> nonFinStates = _states.Except(_finStates).ToList();
List<List<int>> partition = new List<List<int>>();
List<List<int>> newPartition = new List<List<int>>();
newPartition.Add(nonFinStates);
newPartition.Add(_finStates);
do {
partition.Clear();
partition.AddRange(newPartition);
newPartition = decompose(partition);
} while(!partitionsAreEqual(partition, newPartition));
foreach (List<int> g in partition)
minFA.addState();
foreach (List<int> g in partition)
{
int gIdx = partition.IndexOf(g);
foreach (char lbl in _labels)
{
int to = findGroupIndex(partition, g.First(), lbl);
minFA.addTransition(gIdx, to, lbl);
if (g.Contains(InitState))
minFA.InitState = gIdx;
else
if (g.Exists(s => _finStates.Contains(s)))
minFA._finStates.Add(gIdx);
}
}
minFA._labels.AddRange(_labels);
minFA.detectDeadStates();
minFA.removeDeadStates();
minFA.removeUnreachableStates();
return minFA;
}
public FiniteAutomate determine()
{
FiniteAutomate detFA = new FiniteAutomate();
Dictionary<int, bool> markedStates = new Dictionary<int, bool>();
Dictionary<int, List<int>> statesMap = new Dictionary<int, List<int>>();
List<int> T = new List<int>();
T.Add(InitState);
int newStateID = detFA.addState(); // state number in det. FA
markedStates.Add(newStateID, false); // state in unmarked
statesMap.Add(newStateID, closure(T, ' ')); // maps state in FA to set of states in current FA
while (markedStates.Values.Contains(false))
{
int curStateID = markedStates.First((s) => (s.Value == false)).Key;
T.Clear();
T.AddRange(statesMap[curStateID]);
markedStates[curStateID] = true;
foreach (char lbl in _labels)
{
detFA.addLabel(lbl);
List<int> newState = closure(closure(T, lbl), ' ');
if (newState.Count != 0)
{
if (!statesMap.Values.ToList().Any(l => l.SequenceEqual(newState))) // (!setInList(newState, statesMap.Values.ToList()))
{
newStateID = detFA.addState();
markedStates.Add(newStateID, false);
statesMap.Add(newStateID, newState);
}
else
newStateID = statesMap.First(sm => (sm.Value.SequenceEqual(newState))).Key;
detFA.addTransition(curStateID, newStateID, lbl);
}
}
}
detFA.evaluateFinStates(FinStates, statesMap);
return detFA;
}
