private static Result <Grammar> CompileGrammar() { return(DSLCompiler. Compile(new CompilerOptions() { InputGrammarText = File.ReadAllText(GrammarPath), References = CompilerReference.FromAssemblyFiles(typeof(Semantics).GetTypeInfo().Assembly) })); }
public static void Main(string[] args) { var parseResult = DSLCompiler.ParseGrammarFromFile("sorta.grammar"); foreach (var d in parseResult.Diagnostics) { System.Console.WriteLine(d); } if (parseResult.Value == null) { Console.WriteLine("Failed to load grammar (see errors above)"); return; } //--------------------------------------------------------------------------------- var grammar = parseResult.Value; Console.WriteLine("sucessfuly loaded: " + grammar.Name + "\n"); //--------------------------------------------------------------------------------- { ProgramNode p = ProgramNode.Parse("Length(x)", grammar, ASTSerializationFormat.HumanReadable); var inp = new Tuple <string, string>("aaa", "aa"); State input = State.Create(grammar.InputSymbol, inp); Console.WriteLine(p.Invoke(input)); } { /* * ProgramNode p = ProgramNode.Parse("FirstIndexOf(x, 'a')", grammar, ASTSerializationFormat.HumanReadable); * var inp = new Tuple<string, string>("aaa", "aa"); * State input = State.Create(grammar.InputSymbol, inp); * Console.WriteLine(p.Invoke(input)); */ } //--------------------------------------------------------------------------------- var g = grammar; var l = new sorta.Learning.Learners(g); // simple length comparisons Print(Learn(g, l, ex("aab", "bb", Order.Greater))); Print(Learn(g, l, ex("aab", "bb", Order.Less))); Print(Learn(g, l, ex("bb", "aab", Order.Greater))); // Print(Learn(g, l, ex("aab", "bb", Order.Less), ex("bb", "aab", Order.Greater))); // cannot be solved by length alone Print(Learn(g, l, ex("aab", "bb", Order.Greater), ex("bb", "aab", Order.Greater))); // sort by first character Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater))); Print(g, "Oliver Mirele", "Neda Cerise", Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater))); Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Neda Cerise", Order.Greater))); Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Neda Cerise", Order.Less))); }
public Refazer4Python(string pathToGrammar = @"..\..\..\Tutor\synthesis\", string pathToDslLib = @"..\..\..\Tutor\bin\debug") { _pathToGrammar = pathToGrammar; _pathToDslLib = pathToDslLib; Grammar = DSLCompiler.LoadGrammarFromFile(pathToGrammar + @"Transformation.grammar", libraryPaths: new[] { pathToDslLib }); _prose = new SynthesisEngine(Grammar.Value, new SynthesisEngine.Config { LogListener = new LogListener() }); }
public void TestSubstringProgram() { var grammar = DSLCompiler.LoadGrammarFromFile("../../../substring.grammar"); printGrammar(grammar); var program = grammar.Value.ParseAST("Substring(x, AbsPos(7), AbsPos(15))", ASTSerializationFormat.HumanReadable); var input = State.Create(grammar.Value.InputSymbol, "Bjoern Hartmann"); var output = program.Invoke(input) as string; Assert.AreEqual("Hartmann", output); }
static Grammar getGrammar() { var g = DSLCompiler.Compile(new CompilerOptions { InputGrammarText = File.ReadAllText("SExp.grammar"), References = CompilerReference.FromAssemblyFiles( typeof(SExpProgram).GetTypeInfo().Assembly, typeof(Semantics.SExp).GetTypeInfo().Assembly, typeof(Semantics.Semantics).GetTypeInfo().Assembly, typeof(Learning.RankingScore).GetTypeInfo().Assembly) }); return(g.Value); }
public void TestLearnStall() { var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar"); printGrammar(grammar); SynthesisEngine prose = new SynthesisEngine(grammar.Value); //{30.3, -8.9, -19.0, -2.4}; /* * double[] inp1 = new double[4] {10.9, 15.0, -14.5, 12.3}; * double[] out1 = stall(inp1); * var input1 = State.Create(grammar.Value.InputSymbol, inp1); * double[] inp2 = new double[4] {30.3, -8.9, -19.0, -2.4}; * double[] out2 = stall(inp1); * var input2 = State.Create(grammar.Value.InputSymbol, inp1); * var examples = new Dictionary<State, object> { { input1, out1 }, { input2, out2 }}; */ double[] inp1 = new double[4] { 10.9, 15.0, -14.5, 12.3 }; double[] out1 = stall(inp1); var input = State.Create(grammar.Value.InputSymbol, inp1); var examples = new Dictionary <State, object> { { input, out1 } }; var spec = new ExampleSpec(examples); var learnedSet = prose.LearnGrammar(spec); var output = (double[])learnedSet.RealizedPrograms.First().Invoke(input); stdoutprogram(learnedSet.RealizedPrograms.First().ToString(), "Stall"); TestContext.WriteLine("Running random exmaples for Stall"); //test 1000 random examples for (int i = 0; i < 1000; ++i) { var iTmp = genRnd(); var inpTmp = State.Create(grammar.Value.InputSymbol, iTmp); var oTmp = stall(iTmp); var outTmp = (double[])learnedSet.RealizedPrograms.First().Invoke(inpTmp); TestContext.WriteLine("Excpt [{0}]", string.Join(", ", oTmp)); TestContext.WriteLine("Actul [{0}]", string.Join(", ", outTmp)); Assert.AreEqual(oTmp[0], outTmp[0], 0.001d); Assert.AreEqual(oTmp[1], outTmp[1], 0.001d); Assert.AreEqual(oTmp[2], outTmp[2], 0.001d); Assert.AreEqual(oTmp[3], outTmp[3], 0.001d); } }
private LanguageGrammar() { var options = new CompilerOptions { InputGrammarText = GrammarContent, References = CompilerReference.FromAssemblyFiles( typeof(Semantics).GetTypeInfo().Assembly, typeof(Microsoft.ProgramSynthesis.Wrangling.Tree.Node).GetTypeInfo().Assembly) }; Result <Grammar> compile = DSLCompiler.Compile(options); Grammar = compile.Value; }
/// <summary> /// To load the grammar file /// </summary> /// <param name="grammarFile">Location of the grammar file</param> /// <returns></returns> public static Grammar LoadGrammar(string grammarFile) { var compilationResult = DSLCompiler.ParseGrammarFromFile(grammarFile); if (compilationResult.HasErrors) { WriteColored(ConsoleColor.Magenta, compilationResult.TraceDiagnostics); throw new Exception(compilationResult.Exception.InnerException.Message); } if (compilationResult.Diagnostics.Count > 0) { WriteColored(ConsoleColor.Yellow, compilationResult.TraceDiagnostics); } return(compilationResult.Value); }
private static Grammar LoadGrammar(string file, IReadOnlyList <CompilerReference> assemblyReferences) { var compilationResult = DSLCompiler.Compile(new CompilerOptions() { InputGrammarText = File.ReadAllText(file), References = assemblyReferences }); if (compilationResult.HasErrors) { compilationResult.TraceDiagnostics(); return(null); } return(compilationResult.Value); }
public SubmissionFixer(string pathToGrammar = @"..\..\..\Tutor\synthesis\", string pathToDslLib = @"..\..\Tutor\bin\debug") { ProsePrograms = new List <IEnumerable <ProgramNode> >(); UsedPrograms = new Dictionary <string, int>(); if (pathToDslLib == null) { pathToDslLib = "."; } if (pathToGrammar == null) { pathToGrammar = "../../../Tutor/synthesis/"; } grammar = DSLCompiler.LoadGrammarFromFile(pathToGrammar + @"Transformation.grammar", libraryPaths: new[] { pathToDslLib }); }
public void TestLearnStringTransformation() { var grammar = DSLCompiler.LoadGrammarFromFile("../../../substring.grammar"); printGrammar(grammar); SynthesisEngine prose = new SynthesisEngine(grammar.Value); var input = State.Create(grammar.Value.InputSymbol, "Bjoern Hartmann"); var examples = new Dictionary <State, object> { { input, "B. Hartmann" } }; var spec = new ExampleSpec(examples); var learnedSet = prose.LearnGrammar(spec); var output = learnedSet.RealizedPrograms.First().Invoke(input) as string; Assert.AreEqual("Hartmann, B.", output); }
public void testAvgVal() { var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar"); printGrammar(grammar); var ast = grammar.Value.ParseAST("stall(stall(stall(div(add(x), len(x))))))", ASTSerializationFormat.HumanReadable); double[] numbers = new double[4] { 10.9, 15.0, -14.5, 12.3 }; var input = State.Create(grammar.Value.InputSymbol, numbers); var output = (double[])ast.Invoke(input); Assert.AreEqual(5.925, output[0], 0.001d); }
public TransformationsController() { const string grammarFileName = @"Prose/Transformations.grammar"; var reader = new StreamReader(PathToFiles + grammarFileName); var grammar = reader.ReadToEnd(); _grammar = DSLCompiler.Compile( new CompilerOptions() { InputGrammarText = grammar, References = CompilerReference.FromAssemblyFiles( typeof(List <int>).GetTypeInfo().Assembly, typeof(Semantics).GetTypeInfo().Assembly, typeof(Node).GetTypeInfo().Assembly) } ); }
public static Grammar LoadGrammar(string grammarFile, IReadOnlyList <CompilerReference> assemblyReferences) { var compilationResult = DSLCompiler.Compile(new CompilerOptions() { InputGrammarText = File.ReadAllText(grammarFile), References = assemblyReferences }); if (compilationResult.HasErrors) { WriteColored(ConsoleColor.Magenta, compilationResult.TraceDiagnostics); return(null); } if (compilationResult.Diagnostics.Count > 0) { WriteColored(ConsoleColor.Yellow, compilationResult.TraceDiagnostics); } return(compilationResult.Value); }
public static void Main(string[] args) { var parseResult = DSLCompiler.ParseGrammarFromFile("MatrixGrammar.grammar"); parseResult.TraceDiagnostics(); var grammar = parseResult.Value; Console.WriteLine(grammar.Name); //var ast = ProgramNode.Parse("matPlus(matPlus(M, M), M))", grammar, ASTSerializationFormat.HumanReadable); //double[] inp = new double[] { 2, 2, 1, 2, 3, 4 }; System.Random random = new System.Random(); double[] inp = new double[10002]; double[] opt = new double[10002]; inp[0] = 100; inp[1] = 100; opt[0] = 100; opt[1] = 100; for (int i = 2; i < 10002; i++) { double val = random.NextDouble(); inp[i] = val; // NextDouble already returns double from [0,1) opt[i] = 2 * val; } //double[] opt = new double[] { 2, 2, 2, 4, 6, 8 }; var input = State.Create(grammar.InputSymbol, inp); var spec = new ExampleSpec(new Dictionary <State, object> { [input] = opt }); //var engine = new SynthesisEngine(grammar); var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new DeductiveSynthesis(new MatrixLogic(grammar)), } }); ProgramSet learned = engine.LearnGrammar(spec); Console.Write(learned.Size); }
public static void Main(string[] args) { var parseResult = DSLCompiler.ParseGrammarFromFile("SortKeySynthesis.grammar"); parseResult.TraceDiagnostics(); var grammar = parseResult.Value; foreach (var d in parseResult.Diagnostics) { System.Console.WriteLine(d); } if (grammar == null) { Console.WriteLine("Grammar is null"); return; } testForwardExecution(grammar); testLearning(grammar); }
public void TestLearnDiv() { var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar"); printGrammar(grammar); SynthesisEngine prose = new SynthesisEngine(grammar.Value); double[] inp1 = new double[4] { 10.9, 15.0, -14.5, 12.3 }; double[] out1 = new double[4] { 2.725, 0.0, 0.0, 0.0 }; var input = State.Create(grammar.Value.InputSymbol, inp1); var examples = new Dictionary <State, object> { { input, out1 } }; var spec = new ExampleSpec(examples); var learnedSet = prose.LearnGrammar(spec); var output = (double[])learnedSet.RealizedPrograms.First().Invoke(input); Assert.AreEqual(2.725, output[0], 0.001d); }