public void Should_ReturnsNegative_When_CompareTo_Transition()
{
FAState state = new FAState("State1");
FAState state2 = new FAState("State2");
FATransition transition1 = new FATransition('a', state, state2);
FATransition transition2 = new FATransition('b', state, state2);
Assert.AreEqual(-1, transition1.CompareTo(transition2));
}
public void Should_ReturnsZero_When_CompareTo_Transition()
{
FAState state = new FAState("State1");
FAState state2 = new FAState("State2");
FATransition transition1 = new FATransition('a', state, state2);
FATransition transition2 = new FATransition('a', state, state2);
Assert.Zero(transition1.CompareTo(transition2));
}
public void Should_ReturnFalse_When_AddTransition_WithNullFATransition()
{
List <char> alphabet = new List <char>()
{
'a'
};
FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.DFA, alphabet);
FATransition transition = null;
Assert.False(automata.AddTransition(transition));
}
public void Should_ReturnTrue_When_AddTransition_WithFATranstion()
{
List <char> alphabet = new List <char>()
{
'a'
};
FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.DFA, alphabet);
FAState state1 = new FAState("q1", isInitialState: true, isFinalState: true);
FATransition transition = new FATransition('a', state1, state1);
Assert.True(automata.AddTransition(transition));
}
public void Should_ReturnTrue_When_AddTransition_MultipleToStatesInNFA()
{
List <char> alphabet = new List <char>()
{
'a'
};
FiniteAutomata automata = new FiniteAutomata(FiniteAutomataType.NFA, alphabet);
FAState state1 = new FAState("q1", isInitialState: true, isFinalState: true);
FAState state2 = new FAState("q2");
List <FAState> states = new List <FAState>()
{
state1, state2
};
FATransition transition = new FATransition('a', state1, states);
Assert.True(automata.AddTransition(transition));
}
private FiniteAutomata InsertLeftDirectionStates(FiniteAutomata TWDFA, FiniteAutomata DFA)
{
IEnumerable <FATransition> leftTransitions = TWDFA.Transitions.Where(x => !x.Direction);
Queue <FATransition> leftTransitionQueue = new Queue <FATransition>(leftTransitions);
do
{
FATransition transition = leftTransitionQueue.Dequeue();
FAState toState = transition.ToState.First();
IEnumerable <FATransition> l0Transitions = TWDFA.Transitions.Where(x => x.FromState == toState);
FAState targetState = null;
if (l0Transitions.Any(x => !x.Direction))
{
IEnumerable <FATransition> l1Transitions = l0Transitions.Where(x => !x.Direction);
if (l1Transitions.Count() > 1)
{
leftTransitionQueue.Enqueue(transition);
}
else
{
FATransition l1Transition = l1Transitions.First();
FAState l1State = l1Transition.FromState;
targetState = GetOptimalState(l1State, l0Transitions, DFA);
}
}
else
{
targetState = GetOptimalState(toState, l0Transitions, DFA);
}
FATransition newTransition = new FATransition(transition.TransitionSymbol, transition.FromState, targetState);
_ = DFA.AddTransition(newTransition);
} while (leftTransitionQueue.Count > 0);
return(DFA);
}
/// <summary>
/// Converts NFA transitions into the DFA transition, except initial state.
/// </summary>
/// <param name="NFA"></param>
/// <param name="DFA"></param>
/// <returns>Updated DFA object.</returns>
private FiniteAutomata Convert(FiniteAutomata NFA, FiniteAutomata DFA)
{
Queue <FAState> statesQueue = new Queue <FAState>();
// TR: Initial state tarafından eklenen tüm stateleri bulup kuyruğa ekler.
IEnumerable <FAState> states = DFA.States.Where(x => !x.IsInitialState);
foreach (FAState state in states)
{
statesQueue.Enqueue(state);
}
// TR: Kuyruktaki tüm nesneler için çalışır.
do
{
// TR: Kuyruktan sıradaki eleman getirilir.
FAState fromState = statesQueue.Dequeue();
// TR: DFA olduğu için tüm geçişler kullanılmalıdır.
foreach (char symbol in DFA.Alphabet)
{
string[] subStateNames = fromState.StateName.Split(STATE_SEPARATOR);
List <string> newStateNames = new List <string>();
bool isFinalState = false;
foreach (string subStateName in subStateNames)
{
FAState subState = NFA.States.First(x => x.StateName == subStateName);
FATransition subTransition = NFA.Transitions.FirstOrDefault(x => x.FromState == subState && x.TransitionSymbol == symbol);
IEnumerable <FAState> subToStates = subTransition.ToState;
newStateNames.AddNotExists(subToStates.Select(x => x.StateName));
// TR: Herhangi bir state final state ise bu state final olmalıdır.
if (!isFinalState)
{
isFinalState = subToStates.Any(state => state.IsFinalState);
}
}
// TR: Stateleri aralarına ayraç koyarak birleştirir.
string newStateName = string.Join(STATE_SEPARATOR, newStateNames.OrderBy(x => x));
// TR: Hedef state yoksa oluşturulur.
FAState targetState;
if (!DFA.States.Any(x => x.StateName == newStateName))
{
targetState = new FAState(newStateName, isFinalState: isFinalState);
_ = DFA.AddState(targetState);
// TR: Olmayan item kuyruğa da eklenir.
statesQueue.Enqueue(targetState);
}
else
{
targetState = DFA.States.First(x => x.StateName == newStateName);
}
_ = DFA.AddTransition(symbol, fromState.StateName, targetState.StateName);
}
} while (statesQueue.Count > 0);
return(DFA);
}
