static void AutomataSample3()
{
NondeterminedFiniteAutomaton nfa = new NondeterminedFiniteAutomaton();
nfa.AddState("q0");
nfa.AddState("q1");
nfa.AddState("q2");
nfa.AddToFinalStates("q2");
nfa.AddToStartStates("q0");
nfa.AddSymbol("А");
nfa.AddSymbol("Б");
nfa.AddTransition("q0", "q2", "А");
nfa.
AddTransitionBySymbolsSequence("q0", "q1", new List <string>()
{
"А", "Б", "А"
});
nfa.AddTransition("q1", "q2", "Б");
var fromQ0ByA = nfa.GetTransitionDestinations("q0", "А");
if (fromQ0ByA.Count() != 0)
{
Console.WriteLine("Переход по символу А из состояния q0 приведёт в состояния: ");
foreach (var state in fromQ0ByA)
{
Console.Write(state + " ");
}
}
else
{
Console.WriteLine("По символу А из q0 нет переходов.");
}
}
static void AutomataSample2()
{
NondeterminedFiniteAutomaton nfa = new NondeterminedFiniteAutomaton();
nfa.AddState("q0");
nfa.AddToStartStates("q0");
nfa.AddSymbol("a");
nfa.AddToFinalStates("q0");
nfa.AddTransition("q0", "q0", "a");
nfa.AddSymbol("b");
nfa.AddState("q1");
nfa.AddState("q2");
nfa.AddTransition("q0", "q2", "b");
nfa.AddTransition("q2", "q1", "b");
nfa.AddToFinalStates("q1");
var fromQ0ByB = nfa.GetTransitionDestinations("q0", "b");
if (fromQ0ByB.Count() != 0)
{
Console.WriteLine("Переход по символу b из состояния q0 приведёт в состояния: ");
foreach (var state in fromQ0ByB)
{
Console.Write(state + " ");
}
}
else
{
Console.WriteLine("По символу b из q0 нет переходов.");
}
}
public static IEnumerable <string> GetAllDestinationsByEpsilons(NondeterminedFiniteAutomaton epsilonNfa, string startState)
{
Queue <int> front = new Queue <int>();
int[] number = new int[epsilonNfa.NumberOfStates];
int[] father = new int[epsilonNfa.NumberOfStates];
for (int i = 0; i < number.Length; i++)
{
number[i] = 0;
father[i] = 0;
}
int startStateIndex = epsilonNfa.GetStateIndex(startState);
number[startStateIndex] = 1;
front.Enqueue(startStateIndex);
int counterNum = 1;
while (front.Count != 0)
{
int frontHead = front.Dequeue();
var destinationsFrom = epsilonNfa.GetTransitionDestinations(frontHead, 0);
foreach (var state in destinationsFrom)
{
if (number[state] == 0)
{
front.Enqueue(state);
number[state] = ++counterNum;
father[state] = frontHead;
}
}
}
return(epsilonNfa.GetStates().Where((name) => (number[epsilonNfa.GetStateIndex(name)] > 0)));
}
private string[,] NFAToTable(NondeterminedFiniteAutomaton nfa)
{
List <string> alphabet = new List <string>(nfa.GetAlphabet());
alphabet.Add(nfa.GetEpsilonName());
return(StrangeFunc((NamedAutomaton)nfa, new Func <string, string, string>(
(source, symbol) =>
{
List <string> tmp = nfa.GetTransitionDestinations(source, symbol).ToList();
if (tmp == null)
{
return "-";
}
else
{
return string.Join(", ", tmp);
}
}), alphabet, nfa.GetStartStates()));
}
public static NondeterminedFiniteAutomaton GetEquivalentDeletedEpsilons(this
NondeterminedFiniteAutomaton epsilonNfa)
{
NondeterminedFiniteAutomaton noEpsilonsNfa = new NondeterminedFiniteAutomaton();
// копируем состояния и алфавит
var alphabet = epsilonNfa.GetAlphabet();
var states = epsilonNfa.GetStates();
var finalStates = new HashSet <string>(epsilonNfa.GetFinalStates());
var startStates = new HashSet <string>(epsilonNfa.GetStartStates());
noEpsilonsNfa.AddSymbols(alphabet);
noEpsilonsNfa.AddStates(states);
noEpsilonsNfa.SetFinalStates(finalStates);
noEpsilonsNfa.SetStartStates(startStates);
// добавляем необходимые переходы
foreach (var state in states)
{
// состояния в которые мы можем перейти из состояния state, используя эпсилон переходы.
var statesReachByEpsilons = GetAllDestinationsByEpsilons(epsilonNfa, state);
foreach (var symbol in alphabet)
{
// состояния в которые мы можем попасть используя сперва эпсилон переходы,
// а затем символ symbol единажды
var statesReachByEpsilonsAndSymbol = statesReachByEpsilons.SelectMany((reachedByEps)
=> (epsilonNfa.GetTransitionDestinations(reachedByEps, symbol))).Distinct();
// состояния в которые мы можем перейти из состояния state, используя символ symbol единажды
// и эпсилон переходы в любом порядке
var statesOneSymbolAndEpsilons = statesReachByEpsilonsAndSymbol.SelectMany((stateFrom
=> GetAllDestinationsByEpsilons(epsilonNfa, stateFrom))).Distinct();
foreach (var reachedState in statesOneSymbolAndEpsilons)
{
noEpsilonsNfa.AddTransition(state, reachedState, symbol);
}
}
if (startStates.Contains(state))
{
foreach (var s in statesReachByEpsilons)
{
startStates.Add(s);
noEpsilonsNfa.AddToStartStates(s);
}
}
// Если это начальное состояние и из него достижимо заключительное по эпсилон
// то сделаем его заключительным
if (startStates.Contains(state) && statesReachByEpsilons.Any(finalStates.Contains))
{
noEpsilonsNfa.AddToFinalStates(state);
}
}
foreach (var state in finalStates)
{
noEpsilonsNfa.AddToFinalStates(state);
}
return(noEpsilonsNfa);
}
private static HashSet <string> GetAccessibleStates(NondeterminedFiniteAutomaton nfa,
IEnumerable <string> states, string symbol)
{
return(new HashSet <string>(states.SelectMany(
state => nfa.GetTransitionDestinations(state, symbol)).ToList()));
}
