Lots of code

.gitignore

@@ -2,3 +2,4 @@
 out
 FormeleMethoden.iml
 images/
+.DS_Store

src/com/imegumii/DFA.java

@@ -89,6 +89,11 @@ public class DFA<T extends Comparable> extends Automata<T> {
         return this.reverse().toDFA().reverse().toDFA();
     }
 
+    public DFA<String> minimaliseerHopcroft() {
+        HopcroftConverter converter = new HopcroftConverter((DFA<String>) this);
+        return converter.minimize();
+    }
+
     public DFA<T> ontkenning() {
         DFA<T> returnDFA = new DFA<T>(this.symbols);
 

src/com/imegumii/Main.java

@@ -1,5 +1,7 @@
 package com.imegumii;
 
+import jdk.nashorn.internal.runtime.regexp.joni.Regex;
+
 import java.util.TreeSet;
 
 public class Main {
@@ -337,6 +339,60 @@ public class Main {
         geminimaliseerd.ontkenning();
     }
 
+    public static void TestUitOpdrachtBeschrijving() {
+        Character [] characters = {'a', 'b'};
+        NDFA<String> ndfa = new NDFA<String>(characters);
+
+        ndfa.addTransition(new Transition<String>("q0", 'a', "q1"));
+
+        ndfa.addTransition(new Transition<String>("q1", 'b', "q2"));
+        ndfa.addTransition(new Transition<String>("q1", 'b', "q0"));
+
+        ndfa.addTransition(new Transition<String>("q2", 'a', "q0"));
+        ndfa.addTransition(new Transition<String>("q2", 'a', "q3"));
+
+        ndfa.addTransition(new Transition<String>("q3", 'a', "q4"));
+
+        ndfa.defineAsStartState("q0");
+
+        ndfa.defineAsEndState("q0");
+        ndfa.defineAsEndState("q4");
+
+        Graph.generateImage(ndfa, "Ndfa");
+
+        DFA<String> dfa = ndfa.toDFA();
+
+        Graph.generateImage(dfa, "Dfa");
+
+    }
+
+    public static void traverseRegExp(RegExp r) {
+        if (r == null) {
+            return;
+        }
+        System.out.println(r);
+        System.out.println("Printing left ");
+        traverseRegExp(r.links);
+        System.out.println("Printing right");
+        traverseRegExp(r.rechts);
+        System.out.println("----");
+    }
+
+    public static int aantalOperators(RegExp r, int i) {
+        if (r != null) {
+            if (r.links != null) {
+                i++;
+                i = aantalOperators(r.links, i);
+            }
+            if (r.rechts != null) {
+                i++;
+                i = aantalOperators(r.rechts, i);
+            }
+        }
+
+        return i;
+    }
+
     public static void main(String[] args) {
 //        Practicum1();
 
@@ -348,6 +404,42 @@ public class Main {
 
 //        ReverseAutomata();
 
-        Hopcroft();
+//        Hopcroft();
+//        TestUitOpdrachtBeschrijving();
+
+        String s = "a*(aa+ |ba*b ) * (abba|baab|bbbb)+";
+
+
+        String s2 = "a(a+ | b*((a|b)+))";
+        String s3 = "(a|b)+a";
+
+        String s4 = "a+((ab)*b|ab|(b)*bb)+(abba|baab)+";
+
+        RegExp reg = new RegExp();
+//        System.out.println(reg.toRegExp("a*|b+").getTaal(5));
+
+//        RegExp r1 = new RegExp("a");
+//        RegExp r2 = new RegExp("b");
+//
+//        RegExp r3 = r1.punt(r2);
+//
+//        RegExp r4 = new RegExp();
+//
+//        RegExp r5 = r3.punt(r4);
+//
+//        traverseRegExp(r5);
+//        System.out.println(aantalOperators(r5, 1));
+//        System.out.println(r5.getTaal(5));
+
+//        RegExp all = bSter.punt(aPlus);
+//        RegExp all = r1.punt(r2.ster()).punt(r3.plus());
+//
+//        System.out.println(all.getTaal(5));
+//        reg.parseString(s);
+//        reg.parseString(s2);
+//        System.out.println(reg.parseString(s4).getTaal(3));
+        System.out.println(aantalOperators(reg.parseString(s4), 1));
+//        System.out.println(reg.parseString(s3).getTaal(100)); // werkte!
+
     }
 }

src/com/imegumii/RegExp.java

@@ -1,9 +1,8 @@
 package com.imegumii;
 
-import java.util.Comparator;
+import javafx.scene.Parent;
-import java.util.HashSet;
+
-import java.util.SortedSet;
+import java.util.*;
-import java.util.TreeSet;
 
 /**
  * Created by kenny on 2-5-2017.
@@ -40,6 +39,215 @@ public class RegExp {
         rechts = null;
     }
 
+    public RegExp splitOffInParenthesesGroups(String s) {
+        ArrayList<String> parantheses = new ArrayList<>();
+
+        RegExp retval = new RegExp();
+
+        // Vind haakjessets
+        System.out.println("HAKKE");
+        int counter = 0;
+        boolean cutOff = false;
+        int lastIndex = 0;
+        for (int i = 0; i < s.length(); i++) {
+            char current = s.charAt(i);
+            if (current == '(') {
+                if (cutOff) {
+//                    System.out.println("Substring van HAKKE is " + s.substring(lastIndex, i));
+                    parantheses.add(s.substring(lastIndex, i));
+                    lastIndex = i;
+                    cutOff = false;
+                }
+                counter++;
+            }
+            if (current == ')') {
+                counter--;
+            }
+            if (counter == 0) {
+                cutOff = true;
+            }
+        }
+
+//        System.out.println("Substring van HAKKE is " + s.substring(lastIndex, s.length()));
+        parantheses.add(s.substring(lastIndex, s.length()));
+
+        System.out.println("Haakjesset");
+        System.out.println(parantheses);
+
+        for (String paranthesis : parantheses) {
+            findInParantheses(paranthesis, new RegExp());
+        }
+
+        return retval;
+    }
+
+    public RegExp findInParantheses(String s, RegExp startRegExp) {
+        RegExp retval = startRegExp;
+        System.out.println("Begin with string " + s + " in findin");
+
+        Deque<Integer> left = new ArrayDeque<>();
+        Deque<Integer> right = new ArrayDeque<>();
+
+        ArrayList<RegExp> toDot = new ArrayList<>();
+        // Vind haakjes
+        for (int i = 0; i < s.length(); i++) {
+            char current = s.charAt(i);
+
+            if (current == '(') {
+                left.add(i);
+            }
+            if (current == ')') {
+                right.add(i);
+            }
+
+            // Combine the last of left with the first of right
+            if (!left.isEmpty() && !right.isEmpty()) {
+                int start = left.pollLast();
+                int end = right.pollFirst();
+                String substring = s.substring(start + 1, end);
+
+                StringBuilder toReplace = new StringBuilder(s.substring(start, end + 1));
+                StringBuilder replaceWith = new StringBuilder();
+                replaceWith.append(Transition.ENDCHAR);
+                String replacedString = s.replace(toReplace, replaceWith);
+                // Als we een paar haakjes hebben gevonden
+                retval = retval.punt(toRegExp(substring, startRegExp)); // Voeg de regex van de substring toe aan retval
+                retval = retval.punt(findInParantheses(replacedString, retval)); // Haal de substring weg uit de string, vind hiervan de regex en voeg die toe aan retval
+                return retval;
+            }
+        }
+
+
+        if (!s.contains("(") && !s.contains(")")) {
+            retval = retval.punt(toRegExp(s)); // Als we geen haakjes hebben, dan pakken we de huidige (sub)string en voegen we die toe aan retval
+        }
+
+
+        return retval;
+    }
+
+    public static RegExp toRegExp(String start) {
+        return toRegExp(start, new RegExp());
+    }
+
+    public static RegExp toRegExp(String start, RegExp startRegExp) {
+        int maxOps = 200;
+        System.out.println("Begin met " + start + " in toRegExp");
+        System.out.println("STARTREG IS ");
+        System.out.println(startRegExp.getTaal(maxOps));
+
+        RegExp retval = new RegExp();
+        ArrayList<String> strings = new ArrayList<>();
+        ArrayList<RegExp> toOf = new ArrayList<>();
+
+        StringBuilder currentString = new StringBuilder();
+        for (int i = 0; i < start.length(); i++) {
+            char current = start.charAt(i);
+
+            if (current == '|') {
+                // flush currentString to strings array
+                strings.add(currentString.toString());
+                currentString = new StringBuilder();
+                continue;
+            }
+
+            currentString.append(current);
+        }
+
+        strings.add(currentString.toString());
+
+        System.out.println("OfStrings: " + strings);
+
+        for (String s : strings) {
+            System.out.println("Parsing " + s);
+            RegExp total = new RegExp();
+            ArrayList<RegExp> toDot = new ArrayList<>();
+            for (int i = 0; i < s.length(); i++) {
+                char current = s.charAt(i);
+                RegExp prev;
+                switch(current) {
+                    case '*':
+                        prev = toDot.get(toDot.size() -1);
+                        toDot.add(prev.ster());
+                        toDot.remove(prev);
+//                        System.out.println(prev.getTaal(5));
+//                        System.out.println(prev.ster().getTaal(100));
+//                        System.out.println(Main.aantalOperators(prev.ster(), 1));
+                        System.out.println("STER");
+                        break;
+                    case '+':
+                        prev = toDot.get(toDot.size() -1);
+                        toDot.add(prev.plus());
+                        toDot.remove(prev);
+                        System.out.println("PLUS");
+                        break;
+                    case Transition.ENDCHAR:
+                        toDot.add(startRegExp);
+                        System.out.println("PREVIOUS REGEX");
+                        break;
+                    default:
+                        toDot.add(new RegExp("" + current));
+                        System.out.println("NEW CHAR");
+//                        System.out.println("Adding new regExp to toDot");
+                        break;
+                }
+//                System.out.println("-----");
+            }
+//            System.out.println("ToDot contains");
+//            System.out.println(toDot);
+
+            for (RegExp regExp : toDot) {
+                System.out.println("Dotting " + regExp.getTaal(maxOps));
+                total = total.punt(regExp);
+//                System.out.println("Total is: L: (" + total.links + ") R: (" + total.rechts + ")");
+            }
+            System.out.println("Adding to toOf");
+            System.out.println(total.getTaal(maxOps));
+            toOf.add(total);
+        }
+        RegExp prev = null;
+        for (RegExp regExp : toOf) {
+            if (toOf.size() > 1) {
+                if (prev == null) {
+                    prev = regExp;
+                    continue;
+                }
+                System.out.println("Offing " + prev.getTaal(maxOps));
+                System.out.println("With " + regExp.getTaal(maxOps));
+                retval = prev.of(regExp);
+                System.out.println("Result " + retval.getTaal(maxOps));
+                System.out.println("------");
+                prev = retval;
+            } else {
+                retval = retval.punt(regExp);
+            }
+        }
+        System.out.println("toRegExp");
+        System.out.println(Main.aantalOperators(retval, 1));
+        System.out.println(retval.getTaal(200));
+//        Main.traverseRegExp(retval);
+        System.out.println("----");
+
+        return retval;
+    }
+
+    public RegExp removeUselessOperators(RegExp r) {
+        return null;
+    }
+
+    public RegExp parseString(String s) {
+        StringBuilder noSpacesString = new StringBuilder();
+
+        for (char c : s.toCharArray()) {
+            if (c != ' ') {
+                noSpacesString.append(c);
+            }
+        }
+
+        return splitOffInParenthesesGroups(noSpacesString.toString());
+
+    }
+
     public RegExp plus()
     {
         RegExp res = new RegExp();
@@ -96,13 +304,14 @@ public class RegExp {
                 resultaat.addAll (resRechts);
                 break;
 
-
             case PUNT:
                 resLinks = links == null ? leeg : links.getTaal(maxOperaties - 1).getSymbols();
                 resRechts = rechts == null ? leeg : rechts.getTaal(maxOperaties - 1).getSymbols();
-                for (String s1 : resLinks)
+                for (String s1 : resLinks) {
-                    for (String s2 : resRechts)
+                    for (String s2 : resRechts) {
-                    {resultaat.add (s1 + s2);}
+                        resultaat.add(s1 + s2);
+                    }
+                }
                 break;
 
             case STER:
@@ -136,4 +345,8 @@ public class RegExp {
         return new Taal(resultaat);
     }
 
+    @Override
+    public String toString() {
+        return "Chars: " + this.characters + " en operator: " + this.operator;
+    }
 }

src/com/imegumii/TestApplication.java

@@ -0,0 +1,8 @@
+package com.imegumii;
+
+/**
+ * Created by imegumii on 08/06/2017.
+ */
+public class TestApplication {
+
+}