static DisjunctiveExamplesSpec WitnessPositionPair(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary<State, IEnumerable<object>>();
foreach (var example in spec.Examples)
{
State inputState = example.Key;
var inp = (string)inputState[rule.Body[0]];
var substring = (string)example.Value;
var occurrences = new List<Tuple<int?, int?>>();
for (int i = inp.IndexOf(substring); i >= 0; i = inp.IndexOf(substring, i + 1))
{
occurrences.Add(Tuple.Create((int?)i, (int?)i + substring.Length));
}
if (occurrences.Count == 0) return null;
result[inputState] = occurrences;
}
return new DisjunctiveExamplesSpec(result);
}
public static DisjunctiveExamplesSpec WitnessPositionPair(GrammarRule rule, int parameter,
ExampleSpec spec)
{
var ppExamples = new Dictionary<State, IEnumerable<object>>();
foreach (State input in spec.ProvidedInputs)
{
var v = (StringRegion) input[rule.Body[0]];
var desiredOutput = (StringRegion) spec.Examples[input];
var occurrences = new List<object>();
for (int i = v.Value.IndexOf(desiredOutput.Value, StringComparison.Ordinal);
i >= 0;
i = v.Value.IndexOf(desiredOutput.Value, i + 1, StringComparison.Ordinal))
{
occurrences.Add(Tuple.Create(v.Start + (uint?) i, v.Start + (uint?) i + desiredOutput.Length));
}
ppExamples[input] = occurrences;
}
return DisjunctiveExamplesSpec.From(ppExamples);
}
private static void TestFlashFillBenchmark(Grammar grammar, string benchmark, int exampleCount = 2)
{
string[] lines = File.ReadAllLines($"benchmarks/{benchmark}.tsv");
Tuple<string, string>[] data = lines.Select(l =>
{
var parts = l.Split(new[] { "\t" }, StringSplitOptions.RemoveEmptyEntries);
return Tuple.Create(parts[0], parts[1]);
}).ToArray();
var examples = data.Take(exampleCount)
.ToDictionary(t => State.Create(grammar.InputSymbol, StringRegion.Create(t.Item1)),
t => (object) StringRegion.Create(t.Item2));
var spec = new ExampleSpec(examples);
ProgramNode program = Learn(grammar, spec);
foreach (Tuple<string, string> row in data.Skip(exampleCount))
{
State input = State.Create(grammar.InputSymbol, StringRegion.Create(row.Item1));
var output = (StringRegion) program.Invoke(input);
WriteColored(ConsoleColor.DarkCyan, $"{row.Item1} => {output.Value}");
}
}
static void testSynthesis(Grammar grammar, Dictionary<State, object> examples)
{
var spec = new ExampleSpec(examples);
var engine = new SynthesisEngine(grammar);
ProgramSet learned = engine.LearnGrammar(spec);
Console.WriteLine("Examples:");
foreach (KeyValuePair<State, object> ex in examples)
Console.WriteLine("(Input: " + ex.Key + ", Output: " + ex.Value + ")");
Console.WriteLine("These are the programs that I learned");
foreach (ProgramNode p in learned.RealizedPrograms)
{
Console.WriteLine(p);
foreach (State inputExample in examples.Keys)
{
Console.WriteLine("Test: (Input: " + inputExample + ", Output: " + p.Invoke(inputExample) + ")");
}
}
Console.WriteLine();
}
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);
}
public void TestLearnSubstringPositiveAbsPos()
{
//parse grammar file
var grammar = CompileGrammar();
//configure the prose engine
var prose = ConfigureSynthesis(grammar.Value);
//create the example
var input = State.CreateForExecution(grammar.Value.InputSymbol, "19-Feb-1960");
var examples = new Dictionary <State, object> {
{ input, "Feb" }
};
var spec = new ExampleSpec(examples);
//learn the set of programs that satisfy the spec
var learnedSet = prose.LearnGrammar(spec);
//run the first synthesized program in the same input and check if
//the output is correct
var programs = learnedSet.RealizedPrograms;
var output = programs.First().Invoke(input) as string;
Assert.AreEqual("Feb", output);
}
public DisjunctiveExamplesSpec WitnessStartPosition(GrammarRule rule, ExampleSpec spec)
{
var result = new Dictionary <State, IEnumerable <object> >();
foreach (KeyValuePair <State, object> example in spec.Examples)
{
State inputState = example.Key;
var input = inputState[rule.Body[0]] as string;
var output = example.Value as string;
var occurrences = new List <int>();
for (int i = input.IndexOf(output); i >= 0; i = input.IndexOf(output, i + 1))
{
occurrences.Add(i);
}
if (occurrences.Count == 0)
{
return(null);
}
result[inputState] = occurrences.Cast <object>();
}
return(new DisjunctiveExamplesSpec(result));
}
public void TestLearnSubstringOneExample()
{
var grammar = CompileGrammar();
var prose = ConfigureSynthesis(grammar.Value);
var input = State.CreateForExecution(grammar.Value.InputSymbol, "Gustavo Soares");
var examples = new Dictionary <State, object> {
{ input, "Soares" }
};
var spec = new ExampleSpec(examples);
var scoreFeature = new RankingScore(grammar.Value);
var topPrograms = prose.LearnGrammarTopK(spec, scoreFeature, 1, null);
var topProgram = topPrograms.RealizedPrograms.First();
var output = topProgram.Invoke(input) as string;
Assert.AreEqual("Soares", output);
var input2 = State.CreateForExecution(grammar.Value.InputSymbol, "Sumit Gulwani");
var output2 = topProgram.Invoke(input2) as string;
Assert.AreEqual("Gulwani", output2);
}
public static ExampleSpec WitnessContextTemplate(GrammarRule rule, int parameter,
DisjunctiveExamplesSpec spec, ExampleSpec dSpec)
{
var result = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var outerSpec = spec.DisjunctiveExamples[input] as IEnumerable <Tuple <int, PythonNode> >;
var d = (int)dSpec.Examples[input];
var deepSpec = (int)dSpec.Examples[input];
if (outerSpec != null)
{
var node = outerSpec.Where(e => e.Item1 == d).First().Item2;
result[input] = new TreeTemplate(GetAncestor(node, d), node);
}
else
{
return(null);
}
}
return(new ExampleSpec(result));
}
internal DisjunctiveExamplesSpec WitnessSelectWithWhereCondition(GrammarRule rule, ExampleSpec spec)
{
var ppExamples = new Dictionary <State, IEnumerable <object> >();
foreach (State input in spec.ProvidedInputs)
{
var inputTable = ((DataTable[])input[rule.Grammar.InputSymbol])[0];
var outputTable = (DataTable)spec.Examples[input];
var allPossibleSolutions = new List <object>();
var selectQuery = outputTable.PrimaryKey.Select(c => c.ColumnName).ToArray();
var completeRowsList = new List <DataRow[]>();
DataView view = new DataView(outputTable);
List <int> outputCountList = new List <int>();
DataTable distinctValues = view.ToTable(true, selectQuery);
foreach (DataRow row in distinctValues.Rows)
{
var query = string.Join(" AND ", selectQuery.Select(c => (inputTable.Columns[c].DataType == typeof(string))? $"{c}='{row[c]}'":$"{c}={row[c]}"));
completeRowsList.Add(inputTable.Select(query));
outputCountList.Add(outputTable.Select(query).Count());
}
var conditionTables = Utils.Utils.GetAllPossibleTables(completeRowsList, outputCountList, inputTable);
allPossibleSolutions.AddRange(conditionTables);
ppExamples[input] = allPossibleSolutions;
}
//Complete the rows
return(DisjunctiveExamplesSpec.From(ppExamples));
}
public static ExampleSpec WitnessK(GrammarRule rule, int parameter, ExampleSpec spec, ExampleSpec patternSpec)
{
var result = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var inp = (PythonNode)input[rule.Body[0]];
var pattern = patternSpec.Examples[input] as Pattern;
var node = spec.Examples[input] as PythonNode;
if (pattern != null && node != null)
{
var magicK = new MagicK(inp, node);
var k = magicK.GetK(pattern);
result[input] = k;
}
else
{
return(null);
}
}
return(new ExampleSpec(result));
}
public static ExampleSpec WitnessTemplateChildrenTail(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var outerSpec = spec.Examples[input] as List <PythonNode>;
if (outerSpec == null || outerSpec.Count < 2)
{
return(null);
}
var newList = new List <PythonNode>();
newList.AddRange(outerSpec);
newList.RemoveAt(0);
result[input] = newList;
}
return(new ExampleSpec(result));
}
public static ExampleSpec WitnessTemplateChild(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var children = spec.Examples[input] as List <PythonNode>;
if (children == null || children.Count > 1)
{
return(null);
}
if (children.Count.Equals(1))
{
result[input] = children.First();
}
}
return(new ExampleSpec(result));
}
public static ExampleSpec WitnessPatternToken(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (State input in spec.ProvidedInputs)
{
var outerSpec = spec.Examples[input] as TreeTemplate;
if (outerSpec == null)
{
return(null);
}
var innerSpec = new List <PythonNode>();
var pnode = outerSpec.PythonNode;
if (pnode.Children.Any())
{
innerSpec.Add(pnode);
}
result[input] = innerSpec;
}
return(new ExampleSpec(result));
}
public static ExampleSpec WitnessStartPosition(GrammarRule rule, int parameter, ExampleSpec spec)
{
//a result of a witness function is a refined example-based specication
//Each example is a map from an input state (State) to an output value (object)
var result = new Dictionary <State, object>();
//iterate over the input-output examples for Substring operator and refine them to the pos operator
foreach (var example in spec.Examples)
{
State inputState = example.Key;
//Get the input string value from the input state.
var input = inputState[rule.Body[0]] as string;
//Get the output value
var output = example.Value as string;
var refinedExample = input.IndexOf(output);
result[inputState] = refinedExample;
}
return(new ExampleSpec(result));
}
public ExampleSpec WitnessMultiplyEndPosition(GrammarRule rule, ExampleSpec spec, ExampleSpec startSpec)
{
var result = new Dictionary <State, object>();
foreach (KeyValuePair <State, object> example in spec.Examples)
{
State inputState = example.Key;
var input = (Dictionary <uint?, uint?>)inputState[rule.Body[0]];
var output = example.Value as uint?;
var start = (uint?)startSpec.Examples[inputState];
if (output % start == 0 && input.ContainsKey(output / start))
{
result[inputState] = output / start;
}
}
return(new ExampleSpec(result));
}
public DisjunctiveExamplesSpec WitnessMultiplyStartPosition(GrammarRule rule, ExampleSpec spec)
{
var result = new Dictionary <State, IEnumerable <object> >();
foreach (KeyValuePair <State, object> example in spec.Examples)
{
State inputState = example.Key;
var input = (Dictionary <uint?, uint?>)inputState[rule.Body[0]];
var output = example.Value as uint?;
var occurrences = new List <uint?>();
foreach (uint?i in input.Keys)
{
if (i < output)
{
occurrences.Add(i);
}
}
if (occurrences.Count == 0)
{
return(null);
}
result[inputState] = occurrences.Cast <object>();
}
return(new DisjunctiveExamplesSpec(result));
}
private static void LearnFromNewExample()
{
Console.Out.Write("Provide a new input-output example all integers only (e.g., {[1, 2, 3, 4], 7}:"); //\"(Sumit Gulwani)\",\"Gulwani\"): ");
try
{
string input = Console.ReadLine();
if (input != null)
{
int startpos = input.IndexOf("[");
int endpos = input.IndexOf("]");
int final_endpos = input.IndexOf("}");
int num_char_res = final_endpos - (endpos + 3);
int des_result = int.Parse(input.Substring(endpos + 3, num_char_res).ToString());
int num_char = endpos - startpos;
string substr = input.Substring(startpos + 1, num_char - 1);
char[] separator = { ',' };
string[] substrlist = substr.Split(separator);
var numbers = new List <int>();
foreach (string x in substrlist)
{
string temp = x.Trim();
numbers.Add(int.Parse(temp));
}
if (input[0] != '{' || input[1] != '[')
{
throw new Exception(
"Invalid example format. Please try again. Follow exact format, including presense/absence of whitespaces");
}
int[] inputExample = numbers.ToArray();
int outputExample = des_result;
State inputState = State.CreateForExecution(Grammar.InputSymbol, inputExample);
Examples.Add(inputState, outputExample);
}
}
catch (Exception)
{
throw new Exception("Invalid example format. Please try again. Follow exact format, including presense/absence of whitespaces");
}
var spec = new ExampleSpec(Examples);
Console.Out.WriteLine("Learning a program for examples:");
foreach (KeyValuePair <State, object> example in Examples)
{
int[] temp = (int[])example.Key.Bindings.First().Value;
Console.WriteLine("\"{0}\" -> \"{1}\"", example.Key.Bindings.First().Value, example.Value);
}
var scoreFeature = new RankingScore(Grammar);
ProgramSet topPrograms = _prose.LearnGrammarTopK(spec, scoreFeature, 50, null);
if (topPrograms.IsEmpty)
{
throw new Exception("No program was found for this specification.");
}
_topProgram = topPrograms.RealizedPrograms.First();
Console.Out.WriteLine("Top 4 learned programs:");
var counter = 1;
foreach (ProgramNode program in topPrograms.RealizedPrograms)
{
if (counter > 50)
{
break;
}
Console.Out.WriteLine("==========================");
Console.Out.WriteLine("Program {0}: ", counter);
Console.Out.WriteLine(program.PrintAST(ASTSerializationFormat.HumanReadable));
counter++;
}
}
public static DisjunctiveExamplesSpec WitnessRelativeToken(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, IEnumerable <object> >();
foreach (var input in spec.ProvidedInputs)
{
var example = spec.DisjunctiveExamples[input].First() as Tuple <PythonNode, PythonNode>;
if (example != null)
{
//if the anchor node is the target node, we don't generate relative paths
//just the root path "0"
if (AnchorAndTargetAreEqual(example))
{
return(null);
}
var node = example.Item1;
var treeTemplate = new TreeTemplate(node.GetType().Name);
if (node.Value != null)
{
treeTemplate.Value = node.Value;
}
result[input] = new List <TreeTemplate>()
{
treeTemplate, new Wildcard(node.GetType().Name)
};
}
else
{
return(null);
}
}
return(DisjunctiveExamplesSpec.From(result));
}
public static ExampleSpec WitnessEndPosition(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (var example in spec.Examples)
{
State inputState = example.Key;
var input = inputState[rule.Body[0]] as string;
var output = example.Value as string;
var refinedExample = input.IndexOf(output) + output.Length;
result[inputState] = refinedExample;
}
return(new ExampleSpec(result));
}
public static ExampleSpec WitnessLeafPatternToken(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (State input in spec.ProvidedInputs)
{
var outerSpec = spec.Examples[input] as TreeTemplate;
if (outerSpec == null)
{
return(null);
}
result[input] = outerSpec.PythonNode;
}
return(new ExampleSpec(result));
}
public static DisjunctiveExamplesSpec WitnessRegexPair(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, IEnumerable <object> >();
foreach (var example in spec.Examples)
{
State inputState = example.Key;
var input = inputState[rule.Body[0]] as string;
var output = (int)example.Value;
List <Tuple <Match, Regex> >[] leftMatches, rightMatches;
BuildStringMatches(input, out leftMatches, out rightMatches);
var leftRegex = leftMatches[output];
var rightRegex = rightMatches[output];
if (leftRegex.Count == 0 || rightRegex.Count == 0)
{
return(null);
}
var regexes = new List <Tuple <Regex, Regex> >();
regexes.AddRange(from l in leftRegex
from r in rightRegex
select Tuple.Create(l.Item2, r.Item2));
result[inputState] = regexes;
}
return(DisjunctiveExamplesSpec.From(result));
}
public static ExampleSpec WitnessPatternChildren(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (State input in spec.ProvidedInputs)
{
var nodes = spec.Examples[input] as TreeTemplate;
if (nodes == null)
{
return(null);
}
var examples = new List <IEnumerable <PythonNode> >();
if (nodes.PythonNode.Children.Any())
{
examples.Add(nodes.PythonNode.Children);
}
result[input] = examples;
}
return(new ExampleSpec(result));
}
static DisjunctiveExamplesSpec WitnessKForRegexPair(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec, ExampleSpec rrSpec)
{
var result = new Dictionary<State, IEnumerable<object>>();
foreach (var example in spec.DisjunctiveExamples)
{
State inputState = example.Key;
var inp = (string)inputState[rule.Body[0]];
var regexPair = (Tuple<Regex, Regex>)rrSpec.Examples[inputState];
Regex left = regexPair.Item1;
Regex right = regexPair.Item2;
var rightMatches = right.Matches(inp).Cast<Match>().ToDictionary(m => m.Index);
var matchPositions = new List<int>();
foreach (Match m in left.Matches(inp))
{
if (rightMatches.ContainsKey(m.Index + m.Length))
matchPositions.Add(m.Index + m.Length);
}
var ks = new HashSet<int?>();
foreach (int? pos in example.Value)
{
int occurrence = matchPositions.BinarySearch(pos.Value);
if (occurrence < 0) continue;
ks.Add(occurrence);
ks.Add(occurrence - matchPositions.Count);
}
if (ks.Count == 0) return null;
result[inputState] = ks.Cast<object>();
}
return new DisjunctiveExamplesSpec(result);
}
public static ExampleSpec WitnessTemplateChildrenHead(GrammarRule rule, int parameter, ExampleSpec spec)
{
var result = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var outerSpec = spec.Examples[input] as List <PythonNode>;
if (outerSpec == null || outerSpec.Count < 2)
{
return(null);
}
result[input] = outerSpec.First();
}
return(new ExampleSpec(result));
}
[WitnessFunction(nameof(Semantics.Substring), parameterSymbolName: "startPos", DependsOnParameters = new[] { 0, 2 })]// <- name nach .grammar-Datei erwartet. So richtig!
DisjunctiveExamplesSpec WitnessSubstring_startPos(GrammarRule rule, ExampleSpec spec, ExampleSpec spec0, ExampleSpec spec2)
{
var innerSpec = new Dictionary <State, IEnumerable <object> >();
foreach (var example in spec.Examples)
{
//Get the output of this operator
var operatorOutput = (string)example.Value;
var operatorInputs = example.Key;
var completeString = (string)operatorInputs[rule.Body[0]]; //gets the first inputparameter, here string sr
//Find all possible start-positions of operatoroutput in completestring
var possibleStartPositions = new List <int?>();
for (int i = completeString.IndexOf(operatorOutput); i >= 0; i = completeString.IndexOf(operatorOutput, i + 1))
{
possibleStartPositions.Add(i);
}
if (possibleStartPositions.Count == 0)
{
return(null);
}
innerSpec[operatorInputs] = possibleStartPositions.Cast <object>();
}
return(new DisjunctiveExamplesSpec(innerSpec));
}
public static DisjunctiveExamplesSpec WitnessContext(GrammarRule rule, int parameter, ExampleSpec spec)
{
var templateExamples = new Dictionary <State, IEnumerable <object> >();
foreach (var input in spec.ProvidedInputs)
{
var node = spec.Examples[input] as PythonNode;
var ast = (PythonNode)input[rule.Body[0]];
if (ast.ContainsByBinding(node))
{
node = ast.GetCorrespondingNodeByBinding(node);
}
else
{
return(null);
}
var innerSpec = new List <Tuple <int, PythonNode> >()
{
Tuple.Create(0, node)
};
if (node.Parent != null)
{
innerSpec.Add(Tuple.Create(1, node));
}
templateExamples[input] = innerSpec;
}
return(new DisjunctiveExamplesSpec(templateExamples));
}
public static FunctionalDisjunctiveOutputSpec WitnessSortKey(GrammarRule rule, ExampleSpec spec)
{
var fExamples = new Dictionary <State, MultiValueDictionary <object, object> >();
foreach (State input in spec.ProvidedInputs)
{
var inputArray = (string[])input[rule.Body[0]];
var outArray = (string[])spec.Examples[input];
int len = inputArray.Length;
// Get positions for each item in sorted list
var indexes = new int[len];
for (var i = 0; i < len; i++)
{
var item = inputArray[i];
var idx = Array.IndexOf(outArray, item);
if (idx < 0)
{
throw new Exception("Cannot find index in output array");
}
indexes[i] = idx;
}
// Create a dictionary for comparisons spec
var fMap = new MultiValueDictionary <object, object>();
// Loop through all possible pairs
for (var i = 0; i < len - 1; i++)
{
for (var j = i + 1; j < len; j++)
{
var item1 = inputArray[i];
var item2 = inputArray[j];
var idx1 = indexes[i];
var idx2 = indexes[j];
var itemTuple = (Tuple <string, string>)Tuple.Create(item1, item2);
// Two cases are interesting, swaps and splices:
// (1) idx1 > idx2 ==> item1 > item2
// (2) (idx2 - idx1) > (j - i) ==> item2 > item1
if (idx1 > idx2)
{
fMap.Add(itemTuple, 1);
}
else if ((idx2 - idx1) > (j - i))
{
fMap.Add(itemTuple, -1);
}
else
{
// If strict ordering is not found, then
// idx1 < idx2 ==> (item1 <= item2)
fMap.Add(itemTuple, -1);
fMap.Add(itemTuple, 0);
}
}
}
// Add comparisons for this list in the functional spec
fExamples[input] = fMap;
}
return(new FunctionalDisjunctiveOutputSpec(fExamples));
}
public static ExampleSpec WitnessSingleChild(GrammarRule rule, int parameter, ExampleSpec spec)
{
var childrenExamples = new Dictionary <State, object>();
foreach (var input in spec.ProvidedInputs)
{
var children = spec.Examples[input] as IEnumerable <PythonNode>;
if (children.Count().Equals(1))
{
childrenExamples[input] = children.First();
}
else
{
return(null);
}
}
return(new ExampleSpec(childrenExamples));
}
internal DisjunctiveExamplesSpec WitnessSelectWithWhereColumnArray(GrammarRule rule, DisjunctiveExamplesSpec spec, ExampleSpec conditionSpec)
{
var ppExamples = new Dictionary <State, IEnumerable <object> >();
var conditionTable = (DataTable)conditionSpec.Examples.Values.First();
foreach (State input in spec.ProvidedInputs)
{
DataTable inputTable = ((DataTable[])input[rule.Grammar.InputSymbol])[0];
var desiredOutput = (DataTable)spec.DisjunctiveExamples[input].First(); // conditionTable;
var allPossibleSolutions = new List <object>();
allPossibleSolutions.Add(desiredOutput.Columns.Cast <DataColumn>().ToArray());
ppExamples[input] = allPossibleSolutions;
}
//Complete the rows
return(DisjunctiveExamplesSpec.From(ppExamples));
}
DisjunctiveExamplesSpec WitnessRegexFunction_iTH(GrammarRule rule, ExampleSpec spec, ExampleSpec regexSpec)
{
var result = new Dictionary <State, IEnumerable <object> >();
// Die erste Spec ist die "äußere spec", die die beispiele enthält
foreach (var example in spec.Examples)
{
var functionInput = (string)example.Key[rule.Body[2]]; //TODO funktioniert das so? 0 -> der index zeigt die position in der ganzen grammatik an, und 0 ist der input. oder muss hier eine 2 hin? -> index zeigt die position in der parameterliste an. TESTEN!
var regex = new Regex(""); // (Regex)regexSpec.Examples[example.Key];
var completeString = "";
var programOutput = (string)example.Value; // TODO ?
//TODO match regex to input and write back, which match-indices have a match, where the output starts, too
var possibleNs = new HashSet <int>();
var matches = regex.Matches(functionInput);
var possibleStartPositions = new List <int?>();
for (int i = functionInput.IndexOf(programOutput); i >= 0; i = completeString.IndexOf(programOutput, i + 1))
{
possibleStartPositions.Add(i);
}
if (possibleNs.Count == 0)
{
return(null);
}
result[example.Key] = possibleNs.Cast <object>();
}
return(new DisjunctiveExamplesSpec(result));
}
public DisjunctiveExamplesSpec WitnessFilterByProcessProcess(GrammarRule rule, ExampleSpec spec)
{
var examples = new Dictionary <State, IEnumerable <object> >();
foreach (var input in spec.ProvidedInputs)
{
var before = (Node)input[rule.Body[0]];
var after = (List <int>)spec.Examples[input];
var children = before.GetProcesses();
foreach (var child in children)
{
if (Semantics.FilterByProcess(before, child).OrderBy(i => i)
.SequenceEqual(after.OrderBy(i => i)))
{
if (!examples.ContainsKey(input))
{
examples[input] = new List <string>();
}
((List <string>)examples[input]).Add(child);
}
}
}
return(new DisjunctiveExamplesSpec(examples));
}
public DisjunctiveExamplesSpec WitnessMoveLeft(GrammarRule rule, ExampleSpec spec, ExampleSpec positionSpec)
{
var examples = new Dictionary <State, IEnumerable <object> >();
foreach (var input in spec.Examples)
{
var inputState = input.Key;
var before = (Node)inputState[rule.Body[0]];
var position = (int)positionSpec.Examples[inputState];
var after = (Node)spec.Examples[inputState];
if (Semantics.Move(before, position, true).IsEqualTo(after))
{
if (!examples.ContainsKey(inputState))
{
examples[inputState] = new List <object>();
}
if (!(examples[inputState]).Contains(true))
{
((List <object>)examples[inputState]).Add(true);
}
}
if (Semantics.Move(before, position, false).IsEqualTo(after))
{
if (!examples.ContainsKey(inputState))
{
examples[inputState] = new List <object>();
}
if (!(examples[inputState]).Contains(false))
{
((List <object>)examples[inputState]).Add(false);
}
}
}
return(new DisjunctiveExamplesSpec(examples));
}
public static DisjunctiveExamplesSpec WitnessRegexCount(GrammarRule rule, int parameter,
DisjunctiveExamplesSpec spec,
ExampleSpec regexBinding)
{
var kExamples = new Dictionary<State, IEnumerable<object>>();
foreach (State input in spec.ProvidedInputs)
{
var v = (StringRegion) input[rule.Body[0]];
var rr = (Tuple<RegularExpression, RegularExpression>) regexBinding.Examples[input];
var ks = new List<object>();
foreach (uint pos in spec.DisjunctiveExamples[input])
{
var ms = rr.Item1.Run(v).Where(m => rr.Item2.MatchesAt(v, m.Right)).ToArray();
int index = ms.BinarySearchBy(m => m.Right.CompareTo(pos));
if (index < 0) return null;
ks.Add(index + 1);
ks.Add(index - ms.Length);
}
kExamples[input] = ks;
}
return DisjunctiveExamplesSpec.From(kExamples);
}
private static void LearnFromNewExample()
{
Console.Out.Write("Provide a new input-output example (e.g., \"(Sumit Gulwani)\",\"Gulwani\"): ");
try
{
string input = Console.ReadLine();
if (input != null)
{
int startFirstExample = input.IndexOf("\"", StringComparison.Ordinal) + 1;
int endFirstExample = input.IndexOf("\"", startFirstExample + 1, StringComparison.Ordinal) + 1;
int startSecondExample = input.IndexOf("\"", endFirstExample + 1, StringComparison.Ordinal) + 1;
int endSecondExample = input.IndexOf("\"", startSecondExample + 1, StringComparison.Ordinal) + 1;
if (startFirstExample >= endFirstExample || startSecondExample >= endSecondExample)
{
throw new Exception(
"Invalid example format. Please try again. input and out should be between quotes");
}
string inputExample = input.Substring(startFirstExample, endFirstExample - startFirstExample - 1);
string outputExample =
input.Substring(startSecondExample, endSecondExample - startSecondExample - 1);
State inputState = State.CreateForExecution(Grammar.InputSymbol, inputExample);
Examples.Add(inputState, outputExample);
}
}
catch (Exception)
{
throw new Exception("Invalid example format. Please try again. input and out should be between quotes");
}
var spec = new ExampleSpec(Examples);
Console.Out.WriteLine("Learning a program for examples:");
foreach (KeyValuePair <State, object> example in Examples)
{
Console.WriteLine("\"{0}\" -> \"{1}\"", example.Key.Bindings.First().Value, example.Value);
}
var scoreFeature = new RankingScore(Grammar);
ProgramSet topPrograms = _prose.LearnGrammarTopK(spec, scoreFeature, 4, null);
if (topPrograms.IsEmpty)
{
throw new Exception("No program was found for this specification.");
}
_topProgram = topPrograms.RealizedPrograms.First();
Console.Out.WriteLine("Top 4 learned programs:");
var counter = 1;
foreach (ProgramNode program in topPrograms.RealizedPrograms)
{
if (counter > 4)
{
break;
}
Console.Out.WriteLine("==========================");
Console.Out.WriteLine("Program {0}: ", counter);
Console.Out.WriteLine(program.PrintAST(ASTSerializationFormat.HumanReadable));
counter++;
}
}
public static DisjunctiveExamplesSpec WitnessMoveK(GrammarRule rule, int parameter, ExampleSpec spec)
{
var contextExamples = new Dictionary <State, IEnumerable <object> >();
foreach (State input in spec.ProvidedInputs)
{
var operation = spec.Examples[input] as Move;
if (operation == null)
{
return(null);
}
var positions = new List <int>();
positions.Add(operation.Index);
if (operation.Index == operation.TargetNode.Children.Count)
{
positions.Add(-1);
}
contextExamples[input] = positions.Cast <object>();
}
return(DisjunctiveExamplesSpec.From(contextExamples));
}
