internal string ToCode(GrammaticalObject go) { int moddedCodon = 0; if (go[NewNonTerminalName] == null || go[NewNonTerminalName].Count == 0) { throw new EmptyProductionRuleCollection(NewNonTerminalName, go); } if (go[NewNonTerminalName].Count > 1) { byte codon = go.instance.NextCodon(); if (go.FirstUsedIndex == -1) { go.FirstUsedIndex = go.instance.codonPosition; } go.LastUsedIndex = go.instance.codonPosition; moddedCodon = (int)codon % go[NewNonTerminalName].Count; } ProductionRule chosenProductionRule = go[NewNonTerminalName][moddedCodon]; return(go.ConvertToCode(chosenProductionRule)); }
private static Tuple <int, bool> EvaluateExpression(string code, GrammaticalObject go) { bool canExecute = !code.Contains("a") && !code.Contains("b") && !code.Contains("c") && !code.Contains("d") && !code.Contains("e") && !code.Contains("f"); bool canParse = canExecute && code.Length == 1; ExecutionParameters parameters = new ExecutionParameters(genericCodeWrapper.Replace("TYPE", "int"), "CodeExecutor.Executor", "Execute"); int calculatedValue = 0; if (canParse) { calculatedValue = int.Parse(code); } else if (canExecute) { try { calculatedValue = (int)Executor.Execute(parameters, "return " + code + ";"); } catch { canExecute = false; } } return(new Tuple <int, bool>(calculatedValue, canExecute)); }
public void Check(GrammaticalObject go) { if (!Lambda(go)) { throw new ErrorCheckFailException(go, this); } }
internal string Generate(Chromosome genome, GenerationStats currentGenerationStats) { _genome = genome; _currentGenerationStats = currentGenerationStats; string code = ""; bool compileAgain = true; bool correctionApplied = false; while (compileAgain) { try { codonPosition = -1; GrammaticalObject go = (GrammaticalObject)Activator.CreateInstance(StartingGO.GetType()); go.instance = this; go.Initialize(go.GetInitialProductionRules()); code = ConvertToCode(StartingProductionRule, go); break; } catch (ErrorCheck.ErrorCheckFailException e) { compileAgain = false; List <GrammaticalObject> stackTrace = e.exceptionGO.GetStackTrace(); _currentGenerationStats.failedErrorChecks++; for (int stackTracePosition = 0; stackTracePosition < stackTrace.Count && !compileAgain; stackTracePosition++) { int initialPosition = stackTrace[stackTracePosition].FirstUsedIndex; int finalPosition = stackTrace[stackTracePosition].LastUsedIndex; if (CanCorrectChromosome(_genome, initialPosition, finalPosition)) { compileAgain = true; correctionApplied = true; CorrectChromosome(_genome, initialPosition, finalPosition); } } if (!compileAgain) { _currentGenerationStats.failedErrorCorrections++; throw new ErrorCorrectionFailedException(); } } } if (correctionApplied) { _currentGenerationStats.successfulErrorCorrections++; } return(code); }
public T CreateChild <T>() where T : GrammaticalObject { GrammaticalObject blueprintGO = instance.BluePrintGOs.Find(x => x.GetType() == typeof(T)); if (blueprintGO == null) { throw new BluePrintGONotFound(typeof(T)); } GrammaticalObject go = blueprintGO.GetClone(); go.instance = instance; go.Initialize(this);//Creates a copy that has the same production rules as the parent go.Parent = this; return((T)go); }
internal string ConvertToCode(ProductionRule productionRule, GrammaticalObject go) { string finalCode = ""; foreach (Expression expr in productionRule) { if (expr is Terminal) { finalCode += (Terminal)expr; } else if (expr is NonTerminal) { NonTerminal nonTerminal = (NonTerminal)expr; if (nonTerminal.NewGrammaticalObjectLambda == null) { finalCode += nonTerminal.ToCode(go); } else { finalCode += nonTerminal.ToCode(nonTerminal.NewGrammaticalObjectLambda(go)); } } else if (expr is ErrorCheck) { ((ErrorCheck)expr).Check(go); //If an exception is not thrown, the check was passed _currentGenerationStats.passedErrorChecks++; } else if (expr is ObjectAction) { (((ObjectAction)expr)).Execute(go); } else if (expr is ObjectFunction) { finalCode += ConvertToCode(((ObjectFunction)expr).Execute(go), go); } else { throw new NotImplementedException(); } } return(finalCode); }
internal void Execute(GrammaticalObject go) { Lambda(go); }
public ErrorCheckFailException(GrammaticalObject exceptionGO, ErrorCheck failedEC) : base("Failed Error Check in GrammaticalObject \"" + exceptionGO.ToString() + "\".") { this.exceptionGO = exceptionGO; this.failedEC = failedEC; }
public EmptyProductionRuleCollection(string nonTerminalName, GrammaticalObject go) : base("The nonterminal \"" + nonTerminalName + "\" in Grammatical Object \"" + go.GetType().FullName + "\" is empty or null.") { }
internal ProductionRule Execute(GrammaticalObject go) { return(Lambda(go)); }