public Automata<String> Minimization(Automata<String> Automaton)
{
AutomataConverter c = new AutomataConverter();
Automata<String> miniantwoord = c.NDFAToDFA(c.reverseAutomata(c.NDFAToDFA(c.reverseAutomata(Automaton))));
return c.renameStates(miniantwoord);
}
public override void Execute()
{
if (String.IsNullOrWhiteSpace(Supplement))
{
throw new CommandException(
$"Please enter a valid supplement for the command \"{Body}\""
);
}
String[] validSupplements = new String[] {
//"AFN",
"AFD"
};
if (Program.CurrentAutomata != null)
{
try {
var conversionType = Supplement.ToUpper();
if (validSupplements.Contains(conversionType))
{
if (conversionType == "AFN")
{
//Program.CurrentAutomata = AutomataConverter.ToNDFA(Program.CurrentAutomata);
}
else if (conversionType == "AFD")
{
Program.CurrentAutomata = AutomataConverter.ToDFA(Program.CurrentAutomata);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Automata succesfully converted! Type 'show_automata' to see its inner members.");
Console.ResetColor();
}
else
{
Program.LogError($"{Supplement} is not a valid conversion type.");
}
} catch (Exception e) {
Program.LogError(e.Message);
}
}
else
{
Program.LogError("Can't convert. Automata not set.");
}
}
public static void BevatWoord()
{
Console.Clear();
Console.WriteLine("1. Bevat woord");
Automata <string> a = new Automata<string>();
AutomataConverter c = new AutomataConverter();
var ans = Console.ReadLine();
int choice=0;
if (int.TryParse(ans, out choice))
{
switch (choice)
{
case 1:
Console.Clear();
Console.WriteLine("De volgende NDFA/DFA is gegenereerd:");
a = c.renameStates(Tester.generateRandomNdfa());
// a.printTransitions();
Tester.generateAutomataImage(a);
Console.WriteLine("Geef een string mee en kijk of hij word geaccepteerd. (BV: aaabaabaaa)");
var input = Console.ReadLine();
if (a.isStringAccepted(input)) {
Console.WriteLine("De string word geaccepteerd.");
}
else Console.WriteLine("De string word NIET geaccepteerd.");
ResetToMenu();
break;
default:
Console.WriteLine("Deze optie is niet beschikbaar." +
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
break;
}
}
else
{
Console.WriteLine("Vul alstublieft het nummer van de keuze in."+
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
}
}
public static void NdfaToDfa()
{
Console.Clear();
Console.WriteLine("1. NDFA -> DFA (zonder Epsilon)" +
Environment.NewLine + "2. NDFA -> DFA (met Epsilon)" +
Environment.NewLine + "3. NDFA -> DFA (Random NDFA)");
var ans = Console.ReadLine();
AutomataConverter c = new AutomataConverter();
int choice=0;
if (int.TryParse(ans, out choice))
{
switch (choice)
{
case 1:
Console.Clear();
Automata<string> a = Tester.TestNDFA();
Console.WriteLine("De volgende NDFA:");
a.printTransitions();
Tester.generateAutomataImage(a);
Console.WriteLine("is deze DFA: (Druk op een knop)");
Console.ReadLine();
c.NDFAToDFA(a).printTransitions();
Tester.generateAutomataImage(c.NDFAToDFA(a));
ResetToMenu();
break;
case 2:
Console.Clear();
Automata<string> b = Tester.TestNDFA2();
Console.WriteLine("De volgende NDFA:");
b.printTransitions();
Tester.generateAutomataImage(b);
Console.WriteLine("is deze DFA: (Druk op een knop)");
Console.ReadLine();
c.NDFAToDFA(b).printTransitions();
Tester.generateAutomataImage(c.NDFAToDFA(b));
ResetToMenu();
break;
case 3:
Console.Clear();
Automata<string> d= Tester.generateRandomNdfa();
Console.WriteLine("De volgende NDFA:");
d.printTransitions();
Tester.generateAutomataImage(d);
Console.WriteLine("is deze DFA: (Druk op een knop)");
Console.ReadLine();
c.NDFAToDFA(d).printTransitions();
Tester.generateAutomataImage(c.NDFAToDFA(d));
ResetToMenu();
break;
default:
Console.WriteLine("Deze optie is niet beschikbaar." +
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
break;
}
}
else
{
Console.WriteLine("Vul alstublieft het nummer van de keuze in."+
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
}
}
public static void Minimalization()
{
Console.Clear();
Console.WriteLine("1. Minimalization DFA" +
Environment.NewLine + "2. Minimalization Random DFA");
var ans = Console.ReadLine();
AutomataMinimalization m = new AutomataMinimalization();
AutomataConverter c = new AutomataConverter();
int choice=0;
if (int.TryParse(ans, out choice))
{
switch (choice)
{
case 1:
Console.Clear();
Automata<string> a = Tester.TestDFA2 ();
Console.WriteLine("De volgende DFA: ");
a.printTransitions();
Tester.generateAutomataImage(a);
Console.WriteLine("Is in Minimalisatie: (druk op een knop)");
Console.ReadLine();
Automata<String> mini = m.Minimization(a);
mini.printTransitions();
Tester.generateAutomataImage(mini);
ResetToMenu();
break;
case 2:
Console.Clear();
Automata<string> b = c.renameStates(Tester.generateRandomDfa());
Console.WriteLine("De volgende DFA: ");
b.printTransitions();
Tester.generateAutomataImage(b);
Console.WriteLine("Is in Minimalisatie: (druk op een knop)");
Console.ReadLine();
Automata<String> mini2 = m.Minimization(b);
mini2.printTransitions();
Tester.generateAutomataImage(mini2);
ResetToMenu();
break;
default:
Console.WriteLine("Deze optie is niet beschikbaar." +
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
break;
}
}
else
{
Console.WriteLine("Vul alstublieft het nummer van de keuze in."+
Environment.NewLine + "Druk op een knop om terug te gaan");
ResetToMenu();
}
}
public static Automata<String> testReverse(Automata<String> automata)
{
AutomataConverter c = new AutomataConverter();
Automata<String> a = c.reverseAutomata(automata);
return a;
}
public static Automata<String> testConverter(Automata<String> ndfa)
{
AutomataConverter c = new AutomataConverter();
return c.NDFAToDFA(ndfa);
}
public static Automata<String> generateRandomDfa()
{
int num = 0;
Automata<String> auto = new Automata<String>();
char[] alfabet = { 'a', 'b'};
RegularExpression b = Tester.generateRandomRegex(alfabet, 5);
Console.WriteLine(b.ToString() +
Environment.NewLine + "Geeft:");
b.regexToNDFA(ref num, ref auto);
AutomataConverter c = new AutomataConverter();
Automata<String> auto2 = c.NDFAToDFA(auto);
return auto2;
}
public void TestConversion_NDFAe_To_DFA_0()
{
/*
* L = {a,b}*{a}{a,b}{a,b} (AFNe)
*/
Automata automata = new Automata();
String[] symbols = new String[] {
"a", "b"
};
State[] states = new State[] {
new State("q1", false),
new State("q2", false),
new State("q3", false),
new State("q4", false),
new State("q5", true)
};
Transition[] transitions = new Transition[] {
new Transition(states[0], "a", states[0]),
new Transition(states[0], "b", states[0]),
new Transition(states[0], "a", states[1]),
new Transition(states[1], "a", states[2]),
new Transition(states[1], "b", states[2]),
new Transition(states[2], "a", states[3]),
new Transition(states[2], "b", states[3]),
new Transition(states[3], "@", states[4])
};
automata.SetAutomataType(AutomataType.AFNe);
automata.AddSymbols(symbols);
automata.AddStates(states);
automata.AddTransitions(transitions);
automata.SetInitialState(states[0]);
String[] validInputs = new String[] {
"aabb",
"aaabb",
"ababababababababababb",
"ababababaaaaaaaaaaabb",
"aaaaaaaaaaaaaaaaaaaaa",
"bbbbbbbbbbbbbbbbbbabb",
"aaaaaaaaaaaaaabbabaab",
"ababababababababababa"
};
String[] invalidInputs = new String[] {
"abababbbbbbbbbbbbbbbbb",
"ababababababbababaabba",
"Xababababababababaaabb",
"ababababbabababababXab",
"ab",
"bba",
"a",
"b",
""
};
AutomataReader reader = new AutomataReader(automata);
foreach (var x in validInputs)
{
Assert.IsTrue(reader.Matches(x), $"{x} was supposed to match");
}
foreach (var x in invalidInputs)
{
Assert.IsFalse(reader.Matches(x), $"{x} was not supposed to match");
}
Automata convertedAutomata = AutomataConverter.ToDFA(automata);
reader = new AutomataReader(convertedAutomata);
Assert.AreEqual(AutomataType.AFD, convertedAutomata.GetAutomataType());
foreach (var x in validInputs)
{
Assert.IsTrue(reader.Matches(x), $"{x} was supposed to match");
}
foreach (var x in invalidInputs)
{
Assert.IsFalse(reader.Matches(x), $"{x} was not supposed to match");
}
}
public void TestConversion_NDFAe_To_DFA_3()
{
Automata automata = new Automata();
String[] symbols = new String[] {
"a", "b"
};
State[] states = new State[] {
new State("q0", false),
new State("q1", false),
new State("q2", false),
new State("q3", false),
new State("q4", false),
new State("q5", false),
new State("q6", false),
new State("q7", false),
new State("q8", false),
new State("q9", false),
new State("q10", false),
new State("q11", false),
new State("q12", false),
new State("q13", false),
new State("q14", false),
new State("q15", false),
new State("q16", false),
new State("q17", false),
new State("q18", false),
new State("q19", true)
};
Transition[] transitions = new Transition[] {
new Transition(states[0], "@", states[1]),
new Transition(states[1], "@", states[2]),
new Transition(states[1], "@", states[4]),
new Transition(states[2], "a", states[3]),
new Transition(states[3], "@", states[6]),
new Transition(states[4], "@", states[5]),
new Transition(states[5], "@", states[6]),
new Transition(states[6], "@", states[7]),
new Transition(states[7], "@", states[8]),
new Transition(states[7], "@", states[18]),
new Transition(states[8], "@", states[9]),
new Transition(states[9], "@", states[10]),
new Transition(states[9], "@", states[12]),
new Transition(states[10], "b", states[11]),
new Transition(states[11], "@", states[16]),
new Transition(states[12], "b", states[13]),
new Transition(states[13], "@", states[14]),
new Transition(states[14], "a", states[15]),
new Transition(states[15], "@", states[16]),
new Transition(states[16], "@", states[17]),
new Transition(states[17], "@", states[18]),
new Transition(states[17], "@", states[8]),
new Transition(states[18], "@", states[19])
};
automata.SetAutomataType(AutomataType.AFNe);
automata.AddSymbols(symbols);
automata.AddStates(states);
automata.AddTransitions(transitions);
automata.SetInitialState(states[0]);
String[] validInputs = new String[] {
"",
"a",
"b",
"bbbbb",
"aba",
"abab",
"ba",
"bab",
"bbbbbbbbbbbbbbb",
"bbbbbbbbbbbbabbbbb"
};
String[] invalidInputs = new String[] {
"aa",
"aab",
"abaa",
"ababbbbbbbbaa",
"bbbbbbbbbbbbbbaa",
"abbbbbX",
"Xbbbbbaaabbbb",
"ababababababababababaaab",
"babababaabab"
};
AutomataReader reader = new AutomataReader(automata);
foreach (var x in validInputs)
{
Assert.IsTrue(reader.Matches(x), $"{x} was supposed to match");
}
foreach (var x in invalidInputs)
{
Assert.IsFalse(reader.Matches(x), $"{x} was not supposed to match");
}
Automata convertedAutomata = AutomataConverter.ToDFA(automata);
reader = new AutomataReader(convertedAutomata);
Assert.AreEqual(AutomataType.AFD, convertedAutomata.GetAutomataType());
foreach (var x in validInputs)
{
Assert.IsTrue(reader.Matches(x), $"{x} was supposed to match");
}
foreach (var x in invalidInputs)
{
Assert.IsFalse(reader.Matches(x), $"{x} was not supposed to match");
}
}
public void generateLaTeXExam()
{
String tentamenText = frontpageLatex();
// Folder creation
String mainExamFolder = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "/TentamenGenerator/";
String currentExamFolder = "";
String imagesFolder = "";
String date = DateTime.Now.ToString("dd-MM-yyyy_hh:mm:ss");
if (Directory.Exists(mainExamFolder)==false) {
System.IO.Directory.CreateDirectory(mainExamFolder);
}
if (Directory.Exists(mainExamFolder + "Tentamen_"+ date + "/") == false)
{
Console.WriteLine("Created folder: " + "Tentamen_"+date);
System.IO.Directory.CreateDirectory(mainExamFolder + date + "/");
currentExamFolder = mainExamFolder + date + "/";
}
if (currentExamFolder == "")
return;
imagesFolder = currentExamFolder + "Images/";
System.IO.Directory.CreateDirectory(imagesFolder);
AutomataConverter c = new AutomataConverter();
AutomataMinimalization m = new AutomataMinimalization();
// defining regexes
char[] alfabet = {'a', 'b'};
RegularExpression tentamenRegex_regexDFA = Tester.generateRandomRegex(alfabet, 2);
RegularExpression tentamenRegex_regexNDFA = Tester.generateRandomRegex(alfabet, 2);
RegularExpression tentamenRegex_DFAregex = Tester.generateRandomRegex(alfabet, 2);
RegularExpression tentamenRegex_NDFAregex = Tester.generateRandomRegex(alfabet, 2);
RegularExpression tentamenRegex_DFAToGrammar = Tester.generateRandomRegex(alfabet, 2);
RegularExpression tentamenRegex_NDFAToGrammar = Tester.generateRandomRegex(alfabet, 2);
// Generating exam images
Tester.generateAutomataImage(Tester.TestNDFA2(),imagesFolder+"NDFA_FOR_NDFA_TO_DFA.pdf","pdf");
Tester.generateAutomataImage(c.NDFAToDFA(Tester.TestNDFA2()),imagesFolder+"DFA_FOR_NDFA_TO_DFA.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(c.NDFAToDFA(tentamenRegex_regexDFA.regexToNDFA())),imagesFolder+"DFA_FOR_REGEX_TO_DFA.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(tentamenRegex_regexNDFA.regexToNDFA()),imagesFolder+"NDFA_FOR_REGEX_TO_NDFA.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(c.NDFAToDFA(tentamenRegex_DFAregex.regexToNDFA())),imagesFolder+"DFA_FOR_DFA_TO_REGEX.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(tentamenRegex_NDFAregex.regexToNDFA()),imagesFolder+"NDFA_FOR_NDFA_TO_REGEX.pdf","pdf");
Tester.generateAutomataImage(Tester.TestDFA(),imagesFolder+"DFA_FOR_MINIMALISE_DFA.pdf","pdf");
Tester.generateAutomataImage(m.Minimization(Tester.TestDFA()),imagesFolder+"MINIMALISED_DFA_FOR_MINIMALISE_DFA.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(c.NDFAToDFA(tentamenRegex_DFAToGrammar.regexToNDFA())), imagesFolder+"DFA_FOR_DFA_TO_GRAMMAR.pdf","pdf");
Tester.generateAutomataImage(c.renameStates(tentamenRegex_NDFAToGrammar.regexToNDFA()), imagesFolder+"NDFA_FOR_NDFA_TO_GRAMMAR.pdf","pdf");
// Add questions to exam string
tentamenText += exerciseNDFAToDFA(); //NDFA to DFA
tentamenText += exerciseRegexToDFA(tentamenRegex_regexDFA); //Regex to DFA
tentamenText += exerciseRegexToNDFA(tentamenRegex_regexNDFA); //Regex to NDFA
tentamenText += exerciseDFAToRegex(); //DFA to regex
tentamenText += exerciseNDFAToRegex(); //NDFA to regex
tentamenText += exerciseMinimaliseDFA(); //Minimalise DFA
tentamenText += exerciseDFAToGrammar(); //DFA to grammar
tentamenText += exerciseNDFAToGrammar(); //NDFA to grammar
// Add answers to exam string
tentamenText += answersIntro();
tentamenText += answerNDFAToDFA();
tentamenText += answerRegexToDFA();
tentamenText += answerRegexToNDFA();
tentamenText += answerDFAToRegex(tentamenRegex_DFAregex);
tentamenText += answerNDFAToRegex(tentamenRegex_NDFAregex);
tentamenText += answerMinimaliseDFA();
tentamenText += answerDFAToGrammar(c.renameStates(c.NDFAToDFA(tentamenRegex_DFAToGrammar.regexToNDFA())));
tentamenText += answerNDFAToGrammar(c.renameStates(c.NDFAToDFA(tentamenRegex_NDFAToGrammar.regexToNDFA())));
// End exam string
tentamenText += endOfDocument();
// Writing exam to file
System.IO.StreamWriter file = new System.IO.StreamWriter(currentExamFolder+"proeftentamen.tex");
file.WriteLine(tentamenText);
file.Close();
buildAndOpenLaTeXPDF(currentExamFolder);
}
