diff --git a/ChatGPTParsing/.gitignore b/ChatGPTParsing/.gitignore
index d08d94f4e44f0a670046190d2ca2e0f67014e504..c27b429fd39ebd4e298d43ad7de6907743e209cc 100644
--- a/ChatGPTParsing/.gitignore
+++ b/ChatGPTParsing/.gitignore
@@ -1,2 +1,2 @@
/bin/
-.classpath
\ No newline at end of file
+/.classpath
\ No newline at end of file
diff --git a/ChatGPTParsing/src/auxiliary/ListofListContains.java b/ChatGPTParsing/src/auxiliary/ListOfListContains.java
similarity index 87%
rename from ChatGPTParsing/src/auxiliary/ListofListContains.java
rename to ChatGPTParsing/src/auxiliary/ListOfListContains.java
index 35c0b89628716abb6ea5e50a1836b6657edbdc0a..0de5e569e4bfd030e9fb00d8487df6de8ba0d8b2 100644
--- a/ChatGPTParsing/src/auxiliary/ListofListContains.java
+++ b/ChatGPTParsing/src/auxiliary/ListOfListContains.java
@@ -2,7 +2,7 @@ package auxiliary;
import java.util.List;
-public class ListofListContains {
+public class ListOfListContains {
public static boolean contains(List<List<String>> container, List<String> contained) {
for (List<String> c : container) {
diff --git a/ChatGPTParsing/src/auxiliary/ListOfRulesContains.java b/ChatGPTParsing/src/auxiliary/ListOfRulesContains.java
new file mode 100644
index 0000000000000000000000000000000000000000..16922acdb579f34a7580570a0079f3a0c4429192
--- /dev/null
+++ b/ChatGPTParsing/src/auxiliary/ListOfRulesContains.java
@@ -0,0 +1,13 @@
+package auxiliary;
+
+import java.util.List;
+import java.util.Map;
+
+public class ListOfRulesContains {
+
+ public static boolean contains(List<Map<String, List<List<String>>>> container,
+ Map<String, List<List<String>>> contained) {
+ return false;
+ }
+
+}
diff --git a/ChatGPTParsing/src/json/GrammarToJSON.java b/ChatGPTParsing/src/json/GrammarToJSON.java
index 0561a6158bf4f92537c8565dffc089c8d1143824..ec7ffb5ae246fd2a43f84787d41660ffcbf8e1a5 100644
--- a/ChatGPTParsing/src/json/GrammarToJSON.java
+++ b/ChatGPTParsing/src/json/GrammarToJSON.java
@@ -11,6 +11,7 @@ import type3.Type3GrammarGenerator;
public class GrammarToJSON {
Type3GrammarGenerator gen3 = new Type3GrammarGenerator();
+ Type2GrammarGenerator gen2 = new Type2GrammarGenerator();
private String createJSONGrammar(String[] vars, int alphaSize, Map<String, List<List<String>>> rules,
String start) {
@@ -46,8 +47,8 @@ public class GrammarToJSON {
return grammarJSON.toString();
}
- public String createJSONObject(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize, String start,
- int type, int mode, int n) {
+ public List<String> createJSONGrammars(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize,
+ String start, int type, int mode, int n) {
if (type == 3) {
return createJSONObjectType3(vars, alphaSize, maxConclusios, start, mode, n);
} else if (type == 2) {
@@ -57,28 +58,60 @@ public class GrammarToJSON {
}
}
- private String createJSONObjectType3(String[] vars, int alphaSize, int maxConclusios, String start, int mode,
+ private List<String> createJSONObjectType3(String[] vars, int alphaSize, int maxConclusios, String start, int mode,
int n) {
- List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
+ List<Map<String, List<List<String>>>> ruleSets = new LinkedList<>();
switch (mode) {
case 0:
- grammarRuleSets = gen3.genType3GrammarRuleSets0(vars, alphaSize, maxConclusios, start, n);
+ ruleSets = gen3.genType3GrammarRuleSets0(vars, alphaSize, maxConclusios, start, n);
+ break;
+ case 1:
+ ruleSets = gen3.genType3GrammarRuleSets1(vars, alphaSize, maxConclusios, start, n);
+ break;
+ case 2:
+ ruleSets = gen3.genType3GrammarRuleSets2(vars, alphaSize, maxConclusios, start, n);
+ break;
+ case 3:
+ ruleSets = gen3.genType3GrammarRuleSets3(vars, alphaSize, maxConclusios, start, n);
+ break;
+ default:
+ break;
}
-
- return null;
+ List<String> jsonGrammars = new LinkedList<>();
+ for (Map<String, List<List<String>>> ruleSet : ruleSets) {
+ jsonGrammars.add(createJSONGrammar(vars, alphaSize, ruleSet, start));
+ }
+ return jsonGrammars;
}
- private String createJSONObjectType2(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize,
+ private List<String> createJSONObjectType2(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize,
String start, int mode, int n) {
- // TODO Auto-generated method stub
- return null;
+ List<Map<String, List<List<String>>>> ruleSets = new LinkedList<>();
+ switch (mode) {
+ case 0:
+ ruleSets = gen2.genType2GrammarRuleSets0(vars, alphaSize, maxConclusios, maxConclusioSize, n);
+ break;
+ case 1:
+ ruleSets = gen2.genType2GrammarRuleSets1(vars, alphaSize, maxConclusios, maxConclusioSize, start, n);
+ break;
+ case 2:
+ ruleSets = gen2.genType2GrammarRuleSets2(vars, alphaSize, maxConclusios, maxConclusioSize, n);
+ break;
+ case 3:
+ ruleSets = gen2.genType2GrammarRuleSets3(vars, alphaSize, maxConclusios, maxConclusioSize, start, n);
+ break;
+ default:
+ break;
+ }
+ List<String> jsonGrammars = new LinkedList<>();
+ for (Map<String, List<List<String>>> ruleSet : ruleSets) {
+ jsonGrammars.add(createJSONGrammar(vars, alphaSize, ruleSet, start));
+ }
+ return jsonGrammars;
}
public static void main(String[] args) {
- Type2GrammarGenerator g = new Type2GrammarGenerator();
- String[] vars = { "S", "A" };
- Map<String, List<List<String>>> rules = g.genType2GrammarRuleSet(vars, 2, 2, 2);
- System.out.println(rules);
+
}
}
diff --git a/ChatGPTParsing/src/type2/Type2GrammarGenerator.java b/ChatGPTParsing/src/type2/Type2GrammarGenerator.java
index 0c7a145b0ebfe383d5428efb597c9526aec3dd9b..0917986a7224dc76cd469810f5d9d85cdd095a26 100644
--- a/ChatGPTParsing/src/type2/Type2GrammarGenerator.java
+++ b/ChatGPTParsing/src/type2/Type2GrammarGenerator.java
@@ -8,7 +8,7 @@ import java.util.Map;
import java.util.Random;
import java.util.Set;
-import auxiliary.ListofListContains;
+import auxiliary.ListOfListContains;
import co_reachable.CoReachability;
import reachable.Reachability;
@@ -16,7 +16,7 @@ public class Type2GrammarGenerator {
Random random = new Random();
- public Map<String, List<List<String>>> genType2GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
+ private Map<String, List<List<String>>> genType2GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
int maxConclusioSize) {
Map<String, List<List<String>>> rules = new LinkedHashMap<>();
for (String v : vars) {
@@ -31,7 +31,7 @@ public class Type2GrammarGenerator {
int numOfConclusios = random.nextInt(maxConclusios) + 1;
while (conclusios.size() < numOfConclusios) {
List<String> conclusio = genConclusio(alphaSize, vars, maxConclusioSize);
- if (!ListofListContains.contains(conclusios, conclusio)) {
+ if (!ListOfListContains.contains(conclusios, conclusio)) {
conclusios.add(conclusio);
}
}
@@ -65,7 +65,7 @@ public class Type2GrammarGenerator {
return s;
}
- public List<Map<String, List<List<String>>>> genType2GrammarRuleSets(String[] vars, int alphaSize,
+ public List<Map<String, List<List<String>>>> genType2GrammarRuleSets0(String[] vars, int alphaSize,
int maxConclusios, int maxConclusioSize, int n) {
List<Map<String, List<List<String>>>> grammarRuleSets = new LinkedList<>();
while (grammarRuleSets.size() < n) {
diff --git a/ChatGPTParsing/src/type2/Type2Parser.java b/ChatGPTParsing/src/type2/Type2Parser.java
index 56b99f26c2c167c78ab7bc99ff16b82533a60dbf..f672047159596f7bfc8c6ecdc5b5d9eead8428ad 100644
--- a/ChatGPTParsing/src/type2/Type2Parser.java
+++ b/ChatGPTParsing/src/type2/Type2Parser.java
@@ -9,7 +9,7 @@ import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-import auxiliary.ListofListContains;
+import auxiliary.ListOfListContains;
import co_reachable.CoReachability;
import reachable.Reachability;
@@ -137,7 +137,7 @@ public class Type2Parser {
for (List<String> oldConclusio : rule.getValue()) {
List<List<String>> newCons = removeNullable(oldConclusio, nullable);
for (List<String> newCon : newCons) {
- if ((!newCon.isEmpty() && !ListofListContains.contains(newConclusios, newCon))) {
+ if ((!newCon.isEmpty() && !ListOfListContains.contains(newConclusios, newCon))) {
newConclusios.add(newCon);
}
}
@@ -243,7 +243,7 @@ public class Type2Parser {
List<List<String>> newConclusios = new LinkedList<>();
for (String s : chainProdMap.get(premise)) {
for (List<String> newConclusio : chainRulesDeleted.get(s)) {
- if (!ListofListContains.contains(newConclusios, newConclusio)) {
+ if (!ListOfListContains.contains(newConclusios, newConclusio)) {
newConclusios.add(newConclusio);
}
}
@@ -407,7 +407,7 @@ public class Type2Parser {
public boolean isPartOfLanguage(Map<String, List<List<String>>> rules, String word, String start) {
Map<String, List<List<String>>> cnf = createCNF(rules, start);
if (word.isEmpty()) {
- return ListofListContains.contains(cnf.get("S'"), new LinkedList<>());
+ return ListOfListContains.contains(cnf.get("S'"), new LinkedList<>());
}
return cyk(cnf, word, cnf.keySet().contains("S'") ? "S'" : start);
}
diff --git a/ChatGPTParsing/src/type3/Type3GrammarGenerator.java b/ChatGPTParsing/src/type3/Type3GrammarGenerator.java
index 4072002326070459aa626651f5ba028e02264bbf..5dff47d16d346a0bb766ed8f31202399020113b1 100644
--- a/ChatGPTParsing/src/type3/Type3GrammarGenerator.java
+++ b/ChatGPTParsing/src/type3/Type3GrammarGenerator.java
@@ -8,7 +8,7 @@ import java.util.Map;
import java.util.Random;
import java.util.Set;
-import auxiliary.ListofListContains;
+import auxiliary.ListOfListContains;
import co_reachable.CoReachability;
import reachable.Reachability;
@@ -16,7 +16,7 @@ public class Type3GrammarGenerator {
Random random = new Random();
- public Map<String, List<List<String>>> genType3GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
+ private Map<String, List<List<String>>> genType3GrammarRuleSet(String[] vars, int alphaSize, int maxConclusios,
String s) {
Map<String, List<List<String>>> rules = new LinkedHashMap<>();
List<List<String>> conclusios0 = genConclusios(alphaSize, vars, maxConclusios, true);
@@ -34,10 +34,10 @@ public class Type3GrammarGenerator {
conclusios.add(new LinkedList<>());
}
int numOfConclusios = random.nextInt(maxConclusios) + 1;
- while (conclusios.size() < numOfConclusios || ListofListContains.contains(conclusios, new LinkedList<>())
+ while (conclusios.size() < numOfConclusios || ListOfListContains.contains(conclusios, new LinkedList<>())
&& conclusios.size() < numOfConclusios + 1) {
List<String> conclusio = genConclusio(alphaSize, vars);
- if (!ListofListContains.contains(conclusios, conclusio)) {
+ if (!ListOfListContains.contains(conclusios, conclusio)) {
conclusios.add(conclusio);
}
}
diff --git a/ChatGPTParsing/src/type3/Type3Parser.java b/ChatGPTParsing/src/type3/Type3Parser.java
index 05a8cf9863ec21b7b4f21f0a808fd52f0d0127e3..aff9d6658540dcc59c1ae28f9a3ea70ca50c5ef5 100644
--- a/ChatGPTParsing/src/type3/Type3Parser.java
+++ b/ChatGPTParsing/src/type3/Type3Parser.java
@@ -6,14 +6,14 @@ import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import auxiliary.ListofListContains;
+import auxiliary.ListOfListContains;
public class Type3Parser {
private FiniteStateMachine grammarToFSM(Map<String, List<List<String>>> rules, String start) {
Map<String, State> states = new HashMap<>();
for (Entry<String, List<List<String>>> entry : rules.entrySet()) {
- if (entry.getKey().equals(start) && ListofListContains.contains(entry.getValue(), new LinkedList<>())) {
+ if (entry.getKey().equals(start) && ListOfListContains.contains(entry.getValue(), new LinkedList<>())) {
states.put(start, new State(start, true));
} else {
states.put(entry.getKey(), new State(entry.getKey()));
diff --git a/ChatGPTParsing/src/writer/.gitignore b/ChatGPTParsing/src/writer/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e90b7dd35834d0129fffd811ff56c117afcb41d8
--- /dev/null
+++ b/ChatGPTParsing/src/writer/.gitignore
@@ -0,0 +1 @@
+/json.tmp
\ No newline at end of file
diff --git a/ChatGPTParsing/src/writer/Writer.java b/ChatGPTParsing/src/writer/Writer.java
index 7d6d47a5eabc3bf8fd5e22086dda70f7bf5039ab..f4cee6a482add011eeb4a657ef80519c78d57dd0 100644
--- a/ChatGPTParsing/src/writer/Writer.java
+++ b/ChatGPTParsing/src/writer/Writer.java
@@ -3,20 +3,87 @@ package writer;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import json.GrammarToJSON;
+import word_generator.WordGenerator;
public class Writer {
- public void writeToFile(String json) {
+ private static final int DISTINCT_WORDS = 5;
+ private static final int MAX_LENGTH = 5;
+
+ GrammarToJSON jg = new GrammarToJSON();
+ WordGenerator wg = new WordGenerator();
+
+ private List<String> createGrammarWordPairs(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize,
+ String start, int type, int mode, int n) {
+ List<String> grammarWordPairs = new LinkedList<>();
+ List<String> jsonGrammars = jg.createJSONGrammars(vars, alphaSize, maxConclusios, maxConclusioSize, start, type,
+ mode, n);
+ for (String jsonGrammar : jsonGrammars) {
+ Set<String> distinctWords = new HashSet<>();
+ int i = 0;
+ while (i < DISTINCT_WORDS) {
+ String word = wg.wordGenerator(MAX_LENGTH, alphaSize);
+ if (!distinctWords.contains(word)) {
+ distinctWords.add(word);
+ String grammarWordPair = createGrammarWordPair(jsonGrammar, word);
+ grammarWordPairs.add(grammarWordPair);
+ i++;
+ }
+ }
+ }
+ return grammarWordPairs;
+ }
+
+ private String createGrammarWordPair(String jsonGrammar, String word) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("\"grammar\":");
+ sb.append(jsonGrammar);
+ sb.append(",\"word\":");
+ sb.append("\"" + word + "\"");
+ return sb.toString();
+ }
+
+ private void writeToFile(List<String> jsons) {
try (BufferedWriter bw = new BufferedWriter(new FileWriter("src/writer/json.tmp"))) {
- bw.write(97);
+ int i = 1;
+ for (String json : jsons) {
+ bw.write(json);
+ bw.newLine();
+ bw.newLine();
+ if (i != 0 && i % DISTINCT_WORDS == 0) {
+ bw.newLine();
+ }
+ i++;
+ }
} catch (IOException e) {
-
+ e.printStackTrace();
}
}
+ public void writeToFile(String[] vars, int alphaSize, int maxConclusios, int maxConclusioSize, String start,
+ int type, int mode, int n) {
+ List<String> grammarWordPairs = createGrammarWordPairs(vars, alphaSize, maxConclusios, maxConclusioSize, start,
+ type, mode, n);
+ writeToFile(grammarWordPairs);
+ }
+
public static void main(String[] args) {
Writer w = new Writer();
- w.writeToFile("");
+ String[] vars = { "S", "A", "B" };
+ int alphaSize = 2;
+ int maxConclusios = 2;
+ int maxConclusioSize = -1;
+ String start = "S";
+ int type = 3;
+ int mode = 3;
+ int n = 3;
+ w.writeToFile(vars, alphaSize, maxConclusios, maxConclusioSize, start, type, mode, n);
}
}