public CutPoint(ISymbolicExpressionTreeNode parent, int childIndex) { this.Parent = parent; this.ChildIndex = childIndex; this.Child = null; this.grammar = parent.Grammar; }
public CutPoint(ISymbolicExpressionTreeNode parent, ISymbolicExpressionTreeNode child) { this.Parent = parent; this.Child = child; this.ChildIndex = parent.IndexOfSubtree(child); this.grammar = parent.Grammar; }
internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable <int> argumentIndexes, IEnumerable <CutPoint> argumentCutPoints) { foreach (var pair in argumentIndexes.Zip(argumentCutPoints, (a, b) => new { Index = a, CutPoint = b })) { var argSymbol = new Argument(pair.Index); grammar.AddSymbol(argSymbol); grammar.SetSubtreeCount(argSymbol, 0, 0); foreach (var symb in grammar.Symbols) { if (symb is ProgramRootSymbol || symb is StartSymbol) { continue; } if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol)) { grammar.AddAllowedChildSymbol(symb, argSymbol); } else { for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) { if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol, i)) { grammar.AddAllowedChildSymbol(symb, argSymbol, i); } } } } } }
internal static void SetAllowedParentSymbols(ISymbolicExpressionTreeGrammar grammar, ISymbol symbol, ISymbol newSymbol) { foreach (var symb in grammar.Symbols) { if (symb is ProgramRootSymbol) { continue; } if (newSymbol is Argument && symb is StartSymbol) { continue; } if (grammar.IsAllowedChildSymbol(symb, symbol)) { grammar.AddAllowedChildSymbol(symb, newSymbol); } else { for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) { if (grammar.IsAllowedChildSymbol(symb, symbol, i)) { grammar.AddAllowedChildSymbol(symb, newSymbol, i); } } } } }
public static IEnumerable <string> GetSemanticProductionNames(ISymbolicExpressionTreeGrammar grammar) { var symbolNames = grammar.Symbols.Select(x => x.Name); var statementProductionNames = new List <string>(); foreach (var ruleName in SemanticOperatorHelper.StatementProductionRules) { if (symbolNames.Contains(ruleName)) { statementProductionNames.AddRange(((GroupSymbol)grammar.GetSymbol(ruleName)).Symbols.Select(x => x.Name)); } } return(statementProductionNames); }
internal static void SetAllowedParentSymbols(ISymbolicExpressionTreeGrammar grammar, ISymbol symbol, ISymbol newSymbol) { foreach (var symb in grammar.Symbols) { if (symb is ProgramRootSymbol) continue; if (newSymbol is Argument && symb is StartSymbol) continue; if (grammar.IsAllowedChildSymbol(symb, symbol)) grammar.AddAllowedChildSymbol(symb, newSymbol); else { for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) { if (grammar.IsAllowedChildSymbol(symb, symbol, i)) grammar.AddAllowedChildSymbol(symb, newSymbol, i); } } } }
internal static void AddArgumentSymbol(ISymbolicExpressionTreeGrammar originalGrammar, ISymbolicExpressionTreeGrammar grammar, IEnumerable<int> argumentIndexes, IEnumerable<CutPoint> argumentCutPoints) { foreach (var pair in argumentIndexes.Zip(argumentCutPoints, (a, b) => new { Index = a, CutPoint = b })) { var argSymbol = new Argument(pair.Index); grammar.AddSymbol(argSymbol); grammar.SetSubtreeCount(argSymbol, 0, 0); foreach (var symb in grammar.Symbols) { if (symb is ProgramRootSymbol || symb is StartSymbol) continue; if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol)) grammar.AddAllowedChildSymbol(symb, argSymbol); else { for (int i = 0; i < grammar.GetMaximumSubtreeCount(symb); i++) { if (originalGrammar.IsAllowedChildSymbol(symb, pair.CutPoint.Child.Symbol, i)) grammar.AddAllowedChildSymbol(symb, argSymbol, i); } } } } }
protected SymbolicExpressionGrammar(SymbolicExpressionGrammar original, Cloner cloner) : base(original, cloner) { emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this); foreach (ISymbol symbol in symbols.Values) { RegisterSymbolEvents(symbol); } programRootSymbol = cloner.Clone(original.programRootSymbol); startSymbol = cloner.Clone(original.StartSymbol); defunSymbol = cloner.Clone(original.defunSymbol); maximumFunctionArguments = original.maximumFunctionArguments; minimumFunctionArguments = original.minimumFunctionArguments; maximumFunctionDefinitions = original.maximumFunctionDefinitions; minimumFunctionDefinitions = original.minimumFunctionDefinitions; }
protected SymbolicExpressionGrammar(string name, string description) : base(name, description) { emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this); programRootSymbol = new ProgramRootSymbol(); AddSymbol(programRootSymbol); SetSubtreeCount(programRootSymbol, 1, 1); startSymbol = new StartSymbol(); AddSymbol(startSymbol); SetSubtreeCount(startSymbol, 1, 1); defunSymbol = new Defun(); AddSymbol(defunSymbol); SetSubtreeCount(defunSymbol, 1, 1); AddAllowedChildSymbol(programRootSymbol, startSymbol, 0); UpdateAdfConstraints(); }
public static void IsValid(ISymbolicExpressionTreeGrammar grammar) { Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count()); foreach (ISymbol symbol in grammar.AllowedSymbols) { Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count()); for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) { Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count()); } } foreach (var symbol in grammar.ModifyableSymbols) { //check if every symbol has at least one allowed child for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) { Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Any()); } } }
internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable<CutPoint> argumentCutPoints) { if (!grammar.ContainsSymbol(startCutPoint.Child.Symbol)) return; var invokeSym = new InvokeFunction(functionName); grammar.AddSymbol(invokeSym); grammar.SetSubtreeCount(invokeSym, nArgs, nArgs); //allow invoke symbol everywhere, where the child of the startCutPoint was allowed SetAllowedParentSymbols(grammar, startCutPoint.Child.Symbol, invokeSym); if (nArgs > 0) { //set allowed child symbols of invoke symbol foreach (ISymbol child in grammar.Symbols) { if (child.Name == invokeSym.Name) continue; int i = 0; foreach (CutPoint argumentCutPoint in argumentCutPoints) { if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex)) grammar.AddAllowedChildSymbol(invokeSym, child, i); i++; } } } }
private ISymbolicExpressionTree GenerateSimpleTree(ISymbolicExpressionTreeGrammar grammar) { var branch = new SimpleSymbol("branch", "", 2, 2); var leaf = new SimpleSymbol("leaf", "", 0, 0); var root = new SymbolicExpressionTreeTopLevelNode(branch); root.SetGrammar(grammar); var branch0 = new SymbolicExpressionTreeNode(branch); var branch1 = new SymbolicExpressionTreeNode(branch); var leaf0 = new SymbolicExpressionTreeNode(leaf); var leaf1 = new SymbolicExpressionTreeNode(leaf); var leaf2 = new SymbolicExpressionTreeNode(leaf); var leaf3 = new SymbolicExpressionTreeNode(leaf); root.AddSubtree(branch0); root.AddSubtree(branch1); branch0.AddSubtree(leaf0); branch0.AddSubtree(leaf1); branch1.AddSubtree(leaf2); branch1.AddSubtree(leaf3); return(new SymbolicExpressionTree(root)); }
internal static void AddInvokeSymbol(ISymbolicExpressionTreeGrammar grammar, string functionName, int nArgs, CutPoint startCutPoint, IEnumerable <CutPoint> argumentCutPoints) { if (!grammar.ContainsSymbol(startCutPoint.Child.Symbol)) { return; } var invokeSym = new InvokeFunction(functionName); grammar.AddSymbol(invokeSym); grammar.SetSubtreeCount(invokeSym, nArgs, nArgs); //allow invoke symbol everywhere, where the child of the startCutPoint was allowed SetAllowedParentSymbols(grammar, startCutPoint.Child.Symbol, invokeSym); if (nArgs > 0) { //set allowed child symbols of invoke symbol foreach (ISymbol child in grammar.Symbols) { if (child.Name == invokeSym.Name) { continue; } int i = 0; foreach (CutPoint argumentCutPoint in argumentCutPoints) { if (grammar.IsAllowedChildSymbol(argumentCutPoint.Parent.Symbol, child, argumentCutPoint.ChildIndex)) { grammar.AddAllowedChildSymbol(invokeSym, child, i); } i++; } } } }
protected SymbolicExpressionGrammar(bool deserializing) : base(deserializing) { emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this); }
protected SymbolicExpressionGrammar(SymbolicExpressionGrammar original, Cloner cloner) : base(original, cloner) { emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this); foreach (ISymbol symbol in symbols.Values) RegisterSymbolEvents(symbol); programRootSymbol = cloner.Clone(original.programRootSymbol); startSymbol = cloner.Clone(original.StartSymbol); defunSymbol = cloner.Clone(original.defunSymbol); maximumFunctionArguments = original.maximumFunctionArguments; minimumFunctionArguments = original.minimumFunctionArguments; maximumFunctionDefinitions = original.maximumFunctionDefinitions; minimumFunctionDefinitions = original.minimumFunctionDefinitions; }
protected SymbolicExpressionTreeTopLevelNode(SymbolicExpressionTreeTopLevelNode original, Cloner cloner) : base(original, cloner) { grammar = cloner.Clone(original.Grammar); }
public void SetGrammar(ISymbolicExpressionTreeGrammar grammar) { this.grammar = grammar; }
protected SymbolicExpressionGrammar(StorableConstructorFlag _) : base(_) { emptyGrammar = new EmptySymbolicExpressionTreeGrammar(this); }
public static void IsValid(ISymbolicExpressionTreeGrammar grammar) { Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count()); foreach (ISymbol symbol in grammar.AllowedSymbols) { Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count()); for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) { Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count()); } } foreach (var symbol in grammar.ModifyableSymbols) { //check if every symbol has at least one allowed child for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Any()); } }