コード例 #1
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> TestNDFA()
        {
            char []           alphabet = { 'a', 'b' };
            Automata <String> m        = new Automata <String>(alphabet);

            m.addTransition(new Transition <String> ("1", 'a', "2"));
            m.addTransition(new Transition <String> ("2", 'b', "2"));

            m.addTransition(new Transition <String> ("2", 'b', "4"));
            m.addTransition(new Transition <String> ("1", 'a', "3"));

            m.addTransition(new Transition <String> ("3", 'a', "2"));
            m.addTransition(new Transition <String> ("3", 'a', "4"));

            m.addTransition(new Transition <String> ("4", 'a', "3"));

            // only on start state in a dfa:
            m.defineAsStartState("1");

            // two final states:
            m.defineAsFinalState("3");
            m.defineAsFinalState("4");

            return(m);
        }
コード例 #2
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> TestDFA()
        {
            char []           alphabet = { 'a', 'b' };
            Automata <String> m        = new Automata <String>(alphabet);

            m.addTransition(new Transition <String> ("q0", 'a', "q1"));
            m.addTransition(new Transition <String> ("q0", 'b', "q4"));

            m.addTransition(new Transition <String> ("q1", 'a', "q4"));
            m.addTransition(new Transition <String> ("q1", 'b', "q2"));

            m.addTransition(new Transition <String> ("q2", 'a', "q3"));
            m.addTransition(new Transition <String> ("q2", 'b', "q4"));

            m.addTransition(new Transition <String> ("q3", 'a', "q1"));
            m.addTransition(new Transition <String> ("q3", 'b', "q2"));

            // the error state, loops for a and b:
            m.addTransition(new Transition <String> ("q4", 'a'));
            m.addTransition(new Transition <String> ("q4", 'b'));

            // only on start state in a dfa:
            m.defineAsStartState("q0");

            // two final states:
            m.defineAsFinalState("q2");
            m.defineAsFinalState("q3");

            return(m);
        }
コード例 #3
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> TestProcedure2()
        {
            char []           alphabet = { 'a', 'b' };
            Automata <String> m        = new Automata <String>(alphabet);

            m.addTransition(new Transition <String> ("A", 'a', "C"));
            m.addTransition(new Transition <String> ("A", 'b', "B"));
            m.addTransition(new Transition <String> ("A", 'b', "C"));

            m.addTransition(new Transition <String> ("B", 'b', "C"));
            m.addTransition(new Transition <String> ("B", "C"));

            m.addTransition(new Transition <String> ("C", 'a', "D"));
            m.addTransition(new Transition <String> ("C", 'a', "E"));
            m.addTransition(new Transition <String> ("C", 'b', "D"));

            m.addTransition(new Transition <String> ("D", 'a', "B"));
            m.addTransition(new Transition <String> ("D", 'a', "C"));

            m.addTransition(new Transition <String> ("E", 'a'));
            m.addTransition(new Transition <String> ("E", "D"));

            // only on start state in a dfa:
            m.defineAsStartState("A");

            // two final states:
            m.defineAsFinalState("C");
            m.defineAsFinalState("E");

            return(m);
        }
コード例 #4
0
        public Automata <String> renameStates(Automata <String> automaton)
        {
            Automata <String>           renamedAutomaton = new Automata <string>(automaton.getAlphabet());
            Dictionary <String, String> referencer       = new Dictionary <string, string>();
            int counter = 0;

            foreach (String state in automaton.getStates())
            {
                referencer.Add(state, "q" + counter++);
                Console.WriteLine("q" + counter);
            }
            if (automaton.getStates().Contains("Ø"))
            {
                referencer["Ø"] = "Ø";
            }
            foreach (Transition <String> transition in automaton.getTransitions())
            {
                renamedAutomaton.addTransition(new Transition <string>(referencer[transition.getFromState()], transition.getSymbol(), referencer[transition.getToState()]));
            }
            foreach (String state in automaton.getFinalStates())
            {
                renamedAutomaton.defineAsFinalState(referencer[state]);
            }
            foreach (String state in automaton.getStartStates())
            {
                renamedAutomaton.defineAsStartState(referencer[state]);
            }
            return(renamedAutomaton);
        }
コード例 #5
0
        public Automata <String> regexToNDFA(int depth)
        {
            Automata <String> automata = new Automata <String>();

            regexToNDFA(ref depth, ref automata);
            return(automata);
        }
コード例 #6
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        public static void testRegExpThompson()
        {
            RegularExpression exp1, exp2, exp3, exp4, exp5, a, b, c, all, why;

            a = new RegularExpression("a");
            b = new RegularExpression("b");
            c = new RegularExpression("c");

            //exp 1 (baa)
            exp1 = new RegularExpression("baa");
            //exp 2 (ac)
            exp2 = new RegularExpression("ac");
            //exp 4 (baa)+
            exp4 = exp1.plus();
            //exp 5 (ac)*
            exp5 = exp2.star();
            //exp 3 (a|b|c)*
            exp3 = (a.or(b).or(c)).star();
            //all (a|b|c)* (baa)+ (ca)*
            all = exp3.dot(exp4.dot(exp5));
            why = new RegularExpression("baa").plus().star().plus();



            foreach (String o in all.getLanguage(5))
            {
                Console.Write(o + " ");
            }
            Automata <String> auto = new Automata <String>();
            int num = 0;

            why.regexToNDFA(ref num, ref auto);
            return;
        }
コード例 #7
0
        public Automata <String> inverseAutomata(Automata <String> automaton)
        {
            Automata <String> invertedAutomaton = new Automata <string>(automaton.getAlphabet());

            foreach (String state in automaton.getFinalStates())
            {
                invertedAutomaton.defineAsStartState(state);
            }

            foreach (Transition <String> transition in automaton.getTransitions())
            {
                invertedAutomaton.addTransition(transition);
            }

            foreach (String state in automaton.getStates())
            {
                if (!automaton.getFinalStates().Contains(state))
                {
                    invertedAutomaton.defineAsFinalState(state);
                }
            }

            foreach (String state in automaton.getFinalStates())
            {
                if (state != invertedAutomaton.getStartStates().First())
                {
                    invertedAutomaton.addTransition(new Transition <string>(invertedAutomaton.getStartStates().First(), state));
                }
            }


            return(invertedAutomaton);
        }
コード例 #8
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        public static void testRegularExpressionThompson2()
        {
            //This is the regular expression ( (a|b|c|d)|(ab|ad|bc) )+ (aab) (c|cad|cb)*
            RegularExpression exp1, exp2, exp3, exp4, a, b, c, d, ab, ad, bc, abb, cad, cb, all;

            a   = new RegularExpression("a");
            b   = new RegularExpression("b");
            c   = new RegularExpression("c");
            d   = new RegularExpression("d");
            ab  = new RegularExpression("ab");
            ad  = new RegularExpression("ad");
            bc  = new RegularExpression("bc");
            abb = new RegularExpression("abb");
            cad = new RegularExpression("cad");
            cb  = new RegularExpression("cb");

            // (a|b|c|d)
            exp1 = (a.or(b).or(c).or(d));
            // (ab|ad|bc)
            exp2 = (ab.or(ad).or(bc));
            // (c|cad|cb)*
            exp3 = (c.or(cad).or(cb).star());
            // ( (a|b|c|d) | (ab|ad|bc) )+
            exp4 = (exp1.or(exp2).plus());
            // Merge
            all = exp4.dot(abb.dot(exp3));

            Automata <String> auto = new Automata <String>();
            int num = 0;

            all.regexToNDFA(ref num, ref auto);
            generateAutomataImage(auto);
            return;
        }
コード例 #9
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> TestNDFA2()
        {
            char []           alphabet = { 'a', 'b', 'c', 'd' };
            Automata <String> m        = new Automata <String>(alphabet);

            m.addTransition(new Transition <String> ("0", '$', "1"));
            m.addTransition(new Transition <String> ("0", '$', "3"));

            m.addTransition(new Transition <String> ("1", 'b', "2"));
            m.addTransition(new Transition <String> ("3", 'a', "4"));

            m.addTransition(new Transition <String> ("2", '$', "5"));
            m.addTransition(new Transition <String> ("4", '$', "5"));

            m.addTransition(new Transition <String> ("5", '$', "0"));

            m.addTransition(new Transition <String> ("5", '$', "6"));

            m.addTransition(new Transition <String> ("6", 'b', "7"));

            m.addTransition(new Transition <String> ("7", 'c', "8"));

            m.addTransition(new Transition <String> ("8", 'd', "9"));

            // only on start state in a dfa:
            m.defineAsStartState("0");

            // one final state:
            m.defineAsFinalState("9");

            return(m);
        }
コード例 #10
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        public static Automata <String> testReverse(Automata <String> automata)
        {
            AutomataConverter c = new AutomataConverter();
            Automata <String> a = c.reverseAutomata(automata);

            return(a);
        }
コード例 #11
0
        private String answerNDFAToGrammar(Automata <String> automaton)
        {
            String result = "\\section{Grammatica}\n" +
                            regexStringToLatexString((automaton.getGrammar().toBeautifulLatexString()))
                            + "\n\n\\clearpage\n";

            return(result);
        }
コード例 #12
0
 public Automata(Automata <T> autom)
 {
     this.transitions = autom.transitions;
     this.states      = autom.states;
     this.startStates = autom.startStates;
     this.finalStates = autom.finalStates;
     this.setAlphabet(autom.getAlphabet());
 }
コード例 #13
0
        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));
        }
コード例 #14
0
ファイル: Program.cs プロジェクト: guusbeckett/ForGen
        static public 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();
            }
        }
コード例 #15
0
        public Automata <String> DFAToNDFA(Automata <String> Automata)
        {
            SortedSet <char>  alphabet = Automata.getAlphabet();
            Automata <String> ndfa     = new Automata <String>(alphabet);

            foreach (var state in Automata.getStates())
            {
            }
            return(ndfa);
        }
コード例 #16
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> generateRandomNdfa()
        {
            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);
            return(auto);
        }
コード例 #17
0
        //For a set of states
        public SortedSet <String> findMultipleAccessible(Automata <String> Automata, char letter, SortedSet <String> states)
        {
            SortedSet <String> foundStates = new SortedSet <String>();

            foreach (var state in states)
            {
                foreach (var item in Automata.getToStates(state, letter))
                {
                    if (!foundStates.Contains(item))
                    {
                        foundStates.Add(item);
                    }
                }
            }
            return(foundStates);
        }
コード例 #18
0
ファイル: Program.cs プロジェクト: guusbeckett/ForGen
        static public 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();
            }
        }
コード例 #19
0
        public Automata <String> NDFAToDFA(Automata <String> Automata)
        {
            SortedSet <char>  alphabet = Automata.getAlphabet();
            Automata <String> dfa      = new Automata <String>(alphabet);

            foreach (String state in Automata.getStates())
            {
                foreach (var letter in alphabet)
                {
                    foreach (var item in Automata.getToStates(state, letter))
                    {
                        Console.WriteLine("State: " + state + " met Letter: " + letter + " kan ik hier komen: " + item);
                    }
                }
            }
            return(dfa);
        }
コード例 #20
0
        //For a single state

        public SortedSet <String> findStartState(Automata <String> Automata)
        {
            SortedSet <String> foundStates = new SortedSet <String>();

            foreach (var start in Automata.getStartStates())
            {
                foundStates.Add(start);
                foreach (var item in Automata.getToStates(start, '$'))
                {
                    if (!foundStates.Contains(item))
                    {
                        foundStates.Add(item);
                    }
                }
            }
            return(foundStates);
        }
コード例 #21
0
//		public Automata<String> reverseAutomata(Automata<String> automaton)
//		{
//			Automata<String> reversedAutomaton = new Automata<String>(automaton.getAlphabet());
//
//			foreach (Transition<String> transition in automaton.getTransitions())
//			{
//				transition.reverseFromToState();
//				reversedAutomaton.addTransition(transition);
//			}
//
//			foreach (String state in automaton.getStartStates()) {
//				reversedAutomaton.defineAsStartState(state);
//			}
//
//			foreach (String state in automaton.getFinalStates()) {
//				reversedAutomaton.defineAsFinalState(state);
//			}
//			reversedAutomaton.printTransitions();
//
//			reversedAutomaton = inverseAutomata(reversedAutomaton);
//
//			reversedAutomaton.printTransitions();
//			return reversedAutomaton;
//		}

        public Automata <String> reverseAutomata(Automata <String> automaton)
        {
            Automata <String> reversedAutomaton = new Automata <string>(automaton.getAlphabet());

            foreach (Transition <String> transition in automaton.getTransitions())
            {
                reversedAutomaton.addTransition(new Transition <String> (transition.getToState(), transition.getSymbol(), transition.getFromState()));
            }

            foreach (String state in automaton.getFinalStates())
            {
                reversedAutomaton.defineAsStartState(state);
            }

            foreach (String state in automaton.getStartStates())
            {
                reversedAutomaton.defineAsFinalState(state);
            }

            return(reversedAutomaton);
        }
コード例 #22
0
ファイル: Program.cs プロジェクト: guusbeckett/ForGen
        static public void RegExToNdfaDfa()
        {
            Console.Clear();
            Console.WriteLine("1. RegEx -> NDFA");
            var ans                = Console.ReadLine();
            int choice             = 0;
            Automata <String> auto = new Automata <String>();
            int num                = 0;

            if (int.TryParse(ans, out choice))
            {
                switch (choice)
                {
                case 1:
                    Console.Clear();
                    char[]            alfabet = { 'a', 'b', 'c' };
                    RegularExpression b       = Tester.generateRandomRegex(alfabet, 5);
                    Console.WriteLine(b.ToString() +
                                      Environment.NewLine + "Geeft:");
                    b.regexToNDFA(ref num, ref auto);
                    auto.printTransitions();
                    Tester.generateAutomataImage(auto);
                    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();
            }
        }
コード例 #23
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> TestDFA2()
        {
            char []           alphabet = { 'a', 'b' };
            Automata <String> m        = new Automata <String>(alphabet);

            m.addTransition(new Transition <String> ("q0", 'a', "q2"));
            m.addTransition(new Transition <String> ("q0", 'b', "q3"));

            m.addTransition(new Transition <String> ("q1", 'a', "q3"));
            m.addTransition(new Transition <String> ("q1", 'b', "q2"));

            m.addTransition(new Transition <String> ("q2", 'a', "q0"));
            m.addTransition(new Transition <String> ("q2", 'b', "q4"));

            m.addTransition(new Transition <String> ("q3", 'a', "q1"));
            m.addTransition(new Transition <String> ("q3", 'b', "q5"));

            m.addTransition(new Transition <String> ("q4", 'a', "q6"));
            m.addTransition(new Transition <String> ("q4", 'b', "q5"));

            m.addTransition(new Transition <String> ("q5", 'a', "q2"));
            m.addTransition(new Transition <String> ("q5", 'b', "q0"));

            m.addTransition(new Transition <String> ("q6", 'a', "q4"));
            m.addTransition(new Transition <String> ("q6", 'b', "q0"));

            // only on start state in a dfa:
            m.defineAsStartState("q0");

            // final states:
            m.defineAsFinalState("q1");
            m.defineAsFinalState("q3");
            m.defineAsFinalState("q4");
            m.defineAsFinalState("q6");
            return(m);
        }
コード例 #24
0
ファイル: Program.cs プロジェクト: guusbeckett/ForGen
        static public 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();
            }
        }
コード例 #25
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public void generateAutomataImage(Automata <String> automata, string output_file = "", string fileformat = "svg")
        {
            string executable_file = "";
            string file_opener     = "";
            bool   no_open         = false;

            if (output_file != "")
            {
                no_open = true;
            }
            bool windows = false;
            int  p       = (int)Environment.OSVersion.Platform;

            if ((p == 4) || (p == 6) || (p == 128))               //UNIX
            {
                if (output_file == "")
                {
                    if (InputOutput.IsRunningOnMac())
                    {
                        output_file = Path.GetTempPath() + "generatedAutomata." + fileformat;
                    }
                    else
                    {
                        output_file = "/tmp/tmp." + fileformat;
                    }
                }
                executable_file = "dot";
                if (InputOutput.IsRunningOnMac())
                {
                    file_opener = "open";
                }
                else
                {
                    file_opener = "xdg-open";
                }
            }
            else
            {
                windows = true;
                if (output_file == "")
                {
                    output_file = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
                    output_file = output_file + "\\img." + fileformat;
                }
                executable_file = "C:\\Program Files (x86)\\Graphviz2.38\\bin\\dot.exe";
            }

            string dotinfo = automata.printGraphviz();

            try
            {
                ProcessStartInfo startInfo = new ProcessStartInfo();
                startInfo.CreateNoWindow        = false;
                startInfo.UseShellExecute       = false;
                startInfo.FileName              = executable_file;
                startInfo.RedirectStandardInput = true;
                startInfo.WindowStyle           = ProcessWindowStyle.Hidden;
                startInfo.Arguments             = "  -T" + fileformat + " -o " + output_file;

                Process exeProcess = new Process();
                exeProcess.StartInfo = startInfo;
                exeProcess.Start();
                //exeProcess.WaitForInputIdle();
                StreamWriter writer = exeProcess.StandardInput;
                writer.Write(dotinfo);
                writer.Flush();
                writer.WriteLine();
                if (!windows)
                {
                    exeProcess.WaitForInputIdle();
                }
                writer.Close();
                exeProcess.WaitForExit();
                if (!no_open)
                {
                    if (!windows)
                    {
                        Process openProcess = new Process();
                        openProcess.StartInfo.FileName  = file_opener;
                        openProcess.StartInfo.Arguments = output_file;
                        openProcess.Start();
                    }
                    else
                    {
                        Process.Start(output_file);
                    }
                }
            }
            catch
            {
                Console.Write("Random exception");
            }
        }
コード例 #26
0
        public Automata <String> NDFAToDFA(Automata <String> Automaton)
        {
            SortedSet <char>  alphabet = Automaton.getAlphabet();
            Automata <String> dfa      = new Automata <String>(alphabet);
            Dictionary <Transition <String>, SortedSet <String> > transitionsDict = new Dictionary <Transition <String>, SortedSet <String> >();

            dfa.defineAsStartState(prettyPrint(findStartState(Automaton))); //Set startstates for dfa
            foreach (char letter in alphabet)                               //Check all states after the startstate with all the letters in the alphabet
            {
                if (findMultipleAccessible(Automaton, letter, findStartState(Automaton)).Count() == 0)
                {
                    dfa.addTransition(new Transition <string>(prettyPrint(findStartState(Automaton)), letter, "Ø"));
                }
                else
                {
                    SortedSet <String>  toStates      = findMultipleAccessible(Automaton, letter, findStartState(Automaton));
                    Transition <String> newTransition = new Transition <string>(prettyPrint(findStartState(Automaton)), letter, prettyPrint(toStates));
                    transitionsDict.Add(newTransition, toStates);
                    dfa.addTransition(newTransition);
                }
            }

            int tempTransitionsNumber = 0;
            Dictionary <Transition <String>, SortedSet <String> > tempTransitionsDict = new Dictionary <Transition <String>, SortedSet <String> >();

            while (dfa.getTransistionsNumber() != tempTransitionsNumber)
            {
                tempTransitionsNumber = dfa.getTransistionsNumber();
                foreach (KeyValuePair <Transition <String>, SortedSet <String> > pair in transitionsDict)
                {
                    foreach (char letter in alphabet)
                    {
                        if (findMultipleAccessible(Automaton, letter, pair.Value).Count() == 0)
                        {
                            if (dfa.getTransitions().Contains(new Transition <string>(pair.Key.getToState(), letter, "Ø")) == false)
                            {
                                dfa.addTransition(new Transition <string>(pair.Key.getToState(), letter, "Ø"));
                                tempTransitionsDict.Add(new Transition <string>(pair.Key.getToState(), letter, "Ø"), findMultipleAccessible(Automaton, letter, pair.Value));
                            }
                        }
                        else
                        {
                            SortedSet <String>  toStates      = findMultipleAccessible(Automaton, letter, pair.Value);
                            Transition <String> newTransition = new Transition <string>(pair.Key.getToState(), letter, prettyPrint(toStates));
                            if (dfa.getTransitions().Contains(new Transition <string>(pair.Key.getToState(), letter, prettyPrint(toStates))) == false)
                            {
                                tempTransitionsDict.Add(newTransition, toStates);
                                dfa.addTransition(newTransition);
                            }
                        }
                    }
                }
                transitionsDict = transitionsDict.Union(tempTransitionsDict).ToDictionary(k => k.Key, v => v.Value);
            }
            SortedSet <String> tempListFinal = new SortedSet <String>();

            foreach (String stat in dfa.getStates())
            {
                foreach (String endState in Automaton.getFinalStates())
                {
                    if (stat.Contains(endState))
                    {
                        tempListFinal.Add(stat);
                    }
                }
            }
            foreach (String finState in tempListFinal)
            {
                dfa.defineAsFinalState(finState);
            }
            return(dfa);
        }
コード例 #27
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        static public Automata <String> testMinimalization(Automata <String> automata)
        {
            AutomataMinimalization m = new AutomataMinimalization();

            return(m.Minimization(automata));
        }
コード例 #28
0
        public void regexToNDFA(ref int depth, ref Automata <String> automata, string prevstate = null, string nextstate = null)
        {
            //THOMPSON
            if (depth == 0)
            {
                prevstate = "1";
                automata.defineAsStartState(prevstate);
                depth += 2;
            }
            //depth += 1;
            bool nonext = false;

            switch (operate)
            {
            case Operator.OR:
                automata.addTransition(new Transition <string>(prevstate, depth.ToString()));
                String splitstate = depth.ToString();
                depth++;
                String lnewstate = splitstate;
                if (left.operate == Operator.ONE)
                {
                    foreach (char s in left.terminal)
                    {
                        automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        lnewstate = depth.ToString();                                 //NOT PROPERLY IMPLEMENTED BEHAVIOR
                        depth++;
                    }
                }
                else
                {
                    automata.addTransition(new Transition <string>(lnewstate, depth.ToString()));                           //print = print + left.terminal;//left.regexToNDFA(depth, automata);
                    lnewstate = depth.ToString();
                    depth++;
                    String loldstate2 = depth.ToString();
                    depth++;
                    left.regexToNDFA(ref depth, ref automata, lnewstate, loldstate2);
                    lnewstate = loldstate2;
                    //depth++;
                }
                automata.addTransition(new Transition <string>(prevstate, depth.ToString()));
                splitstate = depth.ToString();
                depth++;
                depth++;
                String rnewstate = splitstate;
                if (right.operate == Operator.ONE)
                {
                    foreach (char s in right.terminal)
                    {
                        automata.addTransition(new Transition <string>(rnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        rnewstate = depth.ToString();
                        depth++;
                    }
                }
                else
                {
                    automata.addTransition(new Transition <string>(rnewstate, depth.ToString())); //print = print + left.terminal;//left.regexToNDFA(depth, automata);
                    rnewstate = depth.ToString();                                                 //NOT PROPERLY IMPLEMENTED BEHAVIOR
                    depth++;
                    String roldstate = depth.ToString();
                    depth++;
                    right.regexToNDFA(ref depth, ref automata, rnewstate, roldstate);
                    rnewstate = roldstate;
                    //depth++;
                }
                if (nextstate == null)
                {
                    automata.addTransition(new Transition <string>(lnewstate, depth.ToString()));
                    automata.addTransition(new Transition <string>(rnewstate, depth.ToString()));
                    automata.defineAsFinalState(depth.ToString());
                    depth++;
                }
                else
                {
                    automata.addTransition(new Transition <string>(lnewstate, nextstate));                            //WRONG
                    automata.addTransition(new Transition <string>(rnewstate, nextstate));
                }

                break;

            case Operator.DOT:

                if (nextstate == null)
                {
                    nextstate = depth.ToString();
                    depth++;
                    nonext = true;
                }
                depth++;
                String tmpstate = depth.ToString();
                if (left.operate == Operator.ONE)
                {
                    lnewstate = prevstate;
                    depth++;
                    foreach (char s in left.terminal)
                    {
                        automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        lnewstate = depth.ToString();
                        depth++;
                    }
                    automata.addTransition(new Transition <string>(lnewstate, tmpstate));
                }
                else
                {
                    left.regexToNDFA(ref depth, ref automata, prevstate, tmpstate);
                }
                if (right.operate == Operator.ONE)
                {
                    lnewstate = tmpstate;
                    depth++;
                    foreach (char s in right.terminal)
                    {
                        automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        lnewstate = depth.ToString();
                        depth++;
                    }
                    automata.addTransition(new Transition <string>(lnewstate, nextstate));
                }
                else
                {
                    right.regexToNDFA(ref depth, ref automata, tmpstate, nextstate);
                }
                if (nonext)
                {
                    automata.defineAsFinalState(nextstate);
                }
                break;

            case Operator.ONE:                     //NOT REALLY IMPLEMENTED
                depth++;
                lnewstate = prevstate;
                foreach (char s in terminal)
                {
                    automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                    automata.addToAlphabet(s);
                    lnewstate = depth.ToString();
                    depth++;
                }
                if (nextstate == null)
                {
                    automata.defineAsFinalState((depth - 1).ToString());
                }
                break;

            case Operator.PLUS:
                if (nextstate == null)
                {
                    nextstate = depth.ToString();
                    depth++;
                    nonext = true;
                }
                depth++;
                automata.addTransition(new Transition <string>(prevstate, depth.ToString()));
                lnewstate = depth.ToString();
                String loldstate = depth.ToString();
                depth++;
                if (left.operate == Operator.ONE)
                {
                    foreach (char s in left.terminal)
                    {
                        automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        lnewstate = depth.ToString();
                        depth++;
                    }
                    automata.addTransition(new Transition <string>(lnewstate, loldstate));
                    automata.addTransition(new Transition <string>(lnewstate, depth.ToString()));
                    rnewstate = depth.ToString();
                }
                else
                {
                    rnewstate = depth.ToString();
                    depth++;
                    left.regexToNDFA(ref depth, ref automata, lnewstate, rnewstate);                             //NOT CHECKED, PROBABLY WRONG
                    //automata.addTransition(new Transition<string>(loldstate, depth.ToString()));
                    automata.addTransition(new Transition <string>(rnewstate, lnewstate));
                    automata.addTransition(new Transition <string>(rnewstate, depth.ToString()));
                    rnewstate = depth.ToString();
                }
                if (!nonext)
                {
                    automata.addTransition(new Transition <string>(depth.ToString(), nextstate));
                }
                else
                {
                    depth++;
                    automata.addTransition(new Transition <string>(rnewstate, depth.ToString()));
                    automata.defineAsFinalState(depth.ToString());
                }
                depth++;
                break;

            case Operator.STAR:
                if (depth.ToString() == nextstate)
                {
                    depth++;
                }
                if (nextstate == null)
                {
                    nextstate = depth.ToString();
                    depth++;
                    nonext = true;
                }
                automata.addTransition(new Transition <string>(prevstate, depth.ToString()));
                lnewstate = depth.ToString();
                rnewstate = lnewstate;
                depth++;
                if (left.operate == Operator.ONE)
                {
                    foreach (char s in left.terminal)
                    {
                        automata.addTransition(new Transition <string>(lnewstate, s, depth.ToString()));
                        automata.addToAlphabet(s);
                        lnewstate = depth.ToString();                                 //NOT PROPERLY IMPLEMENTED BEHAVIOR
                        depth++;
                    }
                    automata.addTransition(new Transition <string>(prevstate, nextstate));
                    automata.addTransition(new Transition <string>(lnewstate, rnewstate));
                }
                else
                {
                    automata.addTransition(new Transition <string>(lnewstate, depth.ToString()));                           //print = print + left.terminal;//left.regexToNDFA(depth, automata);
                    loldstate = lnewstate;
                    lnewstate = depth.ToString();
                    depth++;
                    String futurestate = depth.ToString();
                    depth++;
                    left.regexToNDFA(ref depth, ref automata, lnewstate, futurestate);
                    depth++;
                    automata.addTransition(new Transition <string>(futurestate, depth.ToString()));
                    automata.addTransition(new Transition <string>(futurestate, lnewstate));
                    automata.addTransition(new Transition <string>(loldstate, depth.ToString()));
                    lnewstate = depth.ToString();
                    depth++;
                }
                if (!nonext)
                {
                    automata.addTransition(new Transition <string>(lnewstate, nextstate));
                }
                else
                {
                    automata.addTransition(new Transition <string>(lnewstate, depth.ToString()));
                    automata.defineAsFinalState(depth.ToString());
                }
                break;
            }
        }
コード例 #29
0
ファイル: Tester.cs プロジェクト: guusbeckett/ForGen
        public static Automata <String> testConverter(Automata <String> ndfa)
        {
            AutomataConverter c = new AutomataConverter();

            return(c.NDFAToDFA(ndfa));
        }