protected override void OnPreviewMouseDown(MouseButtonEventArgs e) { if (e.ClickCount >= 2) { SearchIO.addAndShowGraphWindow(_opt.copy(), "Location for Option " + _opt.optionNumber + " from RuleSet " + _opt.ruleSetIndex + " Rule #" + _opt.ruleNumber + ": " + StrLocation); } base.OnPreviewMouseDown(e); }
protected override void Run() { var display = (MessageBoxResult.Yes == MessageBox.Show("Would you like to see the graph " + "after each rule application?", "Display Interim Graphs", MessageBoxButton.YesNo, MessageBoxImage.Information, MessageBoxResult.No)); var userChoose = new UserChooseRCA(seedGraph, rulesets, settings, display); //userChoose.InParallel = false; // this is left here to help with debugging var cand = userChoose.GenerateOneCandidate(); SearchIO.addAndShowGraphWindow(cand.graph, "After Rule Application"); SaveResultDialog.Show(settings.filer, cand); }
protected override void Run() { var setupWin = new RandomStartDialog(this); setupWin.ShowDialog(); if (Cancel) { return; } var userChoose = new RandomChooseRCA(seedGraph, rulesets, numOfCalls, display); var cand = userChoose.GenerateOneCandidate(); SearchIO.addAndShowGraphWindow(cand.graph, "After Rule Application"); SaveResultDialog.Show(settings.filer, cand); }
protected override void Run() { Stack <candidate> candidates = new Stack <candidate>(); candidate current = null; Boolean found = false; candidates.Push(seedCandidate); while (!found && (candidates.Count != 0) && !SearchIO.terminateRequest) { current = candidates.Pop(); SearchIO.iteration = current.recipe.Count; SearchIO.miscObject = candidates.Count; if (isCurrentTheGoal(current)) { found = true; } else { int rsIndex = current.activeRuleSetIndex; List <option> ruleChoices = rulesets[rsIndex].recognize(current.graph); foreach (option opt in ruleChoices) { candidate child = current.copy(); transferLmappingToChild(child.graph, current.graph, opt.location); opt.apply(child.graph, null); child.addToRecipe(opt); candidates.Push(child); } } } SearchIO.addAndShowGraphWindow(current.graph, "cand1"); Save(settings.outputDirectory + "\\DFScandidate.xml", current); }
public static void Run(designGraph seed, grammarRule rule, Relaxation RelaxationTemplate = null) { try { if (RelaxationTemplate == null) { RelaxationTemplate = new Relaxation(0); } var rnd = new Random(); int k = 0; var continueTesting = true; SearchIO.output("begin recognizing rule: " + rule.name + "on graph :" + seed.name, 2); var dummyRS = new ruleSet(); dummyRS.Add(rule); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var options = dummyRS.recognize(seed, false, RelaxationTemplate.copy()); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var numOptions = options.Count; if (numOptions == 0) { if (MessageBox.Show("There were no recognized options. Should the rule be relaxed?", "Test Rule Status", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes) { Run(seed, rule, new Relaxation(RelaxationTemplate.NumberAllowable + 1)); } return; } do { var status = "There "; int choice = -1; switch (numOptions) { case 0: throw new Exception("Should not be able to reach here. (Test Rule Chooser, zero options.)"); case 1: status += "was only one recognized option and it applied as shown.\n"; choice = 0; status += options[choice].Relaxations.RelaxationSummary; break; default: status += "were " + numOptions + " recognized locations.\n"; choice = rnd.Next(options.Count); status += options[choice].Relaxations.RelaxationSummary; option.AssignOptionConfluence(options, new candidate(seed, 0), ConfluenceAnalysis.Full); var numberWithConfluence = options.Count(o => (o.confluence.Count > 0)); var maxConfluence = options.Max(o => o.confluence.Count); var withMaxConfluence = options.Count(o => (o.confluence.Count == maxConfluence)); if (numberWithConfluence > 0) { status += "Confluence existed between " + numberWithConfluence + " of them"; if (maxConfluence > 1) { status += "; \nwith " + withMaxConfluence + " options having a confluence with " + maxConfluence + " other options.\n"; } else { status += ".\n"; } } status += "Option #" + choice + " was randomly chosen, and invoked.\n"; break; } if (!continueTesting) { continue; } if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } var chosenOption = options[choice]; { var seedCopy = seed.copy(); SearchProcess.transferLmappingToChild(seedCopy, seed, chosenOption); seed = seedCopy; } chosenOption.apply(seed, null); SearchIO.output("Rule sucessfully applied", 4); SearchIO.addAndShowGraphWindow(seed, "After calling " + ++k + " rules"); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } options = dummyRS.recognize(seed, true, RelaxationTemplate.copy()); if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } numOptions = options.Count; switch (numOptions) { case 0: status += "There are no recognized locations on the new graph"; continueTesting = false; MessageBox.Show(status, "Test Rule Status", MessageBoxButton.OK, MessageBoxImage.Asterisk); break; case 1: status += "There is one recognized location on the new graph. Would you like to invoke it?"; continueTesting = (MessageBox.Show(status, "Continue Applying?", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes); break; default: status += "There are " + options.Count + " recognized locations on the new graph. Would you " + "like to randomly invoke one?"; continueTesting = (MessageBox.Show(status, "Continue Applying?", MessageBoxButton.YesNo, MessageBoxImage.Asterisk, MessageBoxResult.No) == MessageBoxResult.Yes); break; } } while (continueTesting); } catch (Exception exc) { ErrorLogger.Catch(exc); } }
/// <summary> /// Recognizes the choose apply cycle. Here is the main Recognize, Choose, and /// Apply Generation Cycle. It accepts the host candidate (not graph), the index /// of what ruleSet to invoke, and an array of size equal to the number of ruleSets. /// At the end of the process, it returns the updated candidate. The three step /// process may, however exit at any of five places in the loop, these are described below. /// 1. the ruleSet invoked may not have any calls left. This will cause the GenerationStatus /// to be CycleLimit, and the process will execute what is stored in the 3rd position of /// generationSteps, ruleSet->nextGenerationStep[2], either Stop, Loop, GoToPrevious(ruleSet), /// GoToNext(ruleSet), or GoToRuleSet# /// 2. the choice operation has sent a STOP message, or more precisely a negative # or /// a number greater than the list of option. This results in a GenerationStatus of Choice /// and the execution of ruleSet->nextGenerationStep[1] (any of the options stated above). /// 3. there are no rules recognized for the graph. This results in a GenerationStatus of /// NoRules and the execution of ruleSet->nextGenerationStep[3] (any of the options above). /// 4. A trigger rule has been applied. This results in a GenerationStatus of TriggerRule /// and the execution of ruleSet->nextGenerationStep[4] (any of the options stated above). /// 5. the recognize, choose, and apply cycle performed as intended - no abnormal activites. /// This results in a GenerationStatus of Normal and the execution of /// ruleSet->nextGenerationStep[0] (any of the options stated above).*/ /// </summary> /// <param name = "host">The host.</param> /// <param name = "ruleSetIndex">Index of the rule set.</param> /// <param name = "numOfCallsLeft">The num of calls left.</param> protected void RecognizeChooseApplyCycle(candidate host, int ruleSetIndex, int[] numOfCallsLeft) { while ((ruleSetIndex >= 0) && (ruleSetIndex < NumOfRuleSets)) { host.activeRuleSetIndex = ruleSetIndex; SearchIO.output("Active Rule Set = " + ruleSetIndex, 4); #region terminate immediately if there are no cycles left if (numOfCallsLeft[ruleSetIndex] == 0) { /* it is possible that another ruleset intends to invoke this one, but your * number of calls for this set has hit its limit. */ host.GenerationStatus[ruleSetIndex] = GenerationStatuses.CycleLimit; ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.CycleLimit); SearchIO.output("cycle limit reached", 4); continue; } #endregion #region ***** RECOGNIZE ***** SearchIO.output("begin RCA loop for RuleSet #" + ruleSetIndex, 4); var options = Rulesets[ruleSetIndex].recognize(host.graph, InParallel); SearchIO.output("There are " + options.Count + " rule choices.", 4); if (options.Count == 0) { /* There are no rules to recognize, exit here. */ host.GenerationStatus[ruleSetIndex] = GenerationStatuses.NoRules; var newRSIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.NoRules); if (newRSIndex == ruleSetIndex) { throw new Exception("Same ruleset chosen when no rules are recognized."); } ruleSetIndex = newRSIndex; continue; } if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } #endregion #region ***** CHOOSE ***** if (Rulesets[ruleSetIndex].choiceMethod == choiceMethods.Automatic) { choice = new[] { 0 } } ; else { choice = choose(options, host); } if (choice[0] == -1) { host.undoLastRule(); if (Display) { SearchIO.addAndShowGraphWindow(host.graph.copy(), "Revert to after calling " + host.numRulesCalled + " rules"); } continue; } if ((choice == null) || (choice[0] < 0) || (choice[0] >= options.Count)) { SearchIO.output("Choice = #" + IntCollectionConverter.Convert(choice), 4); /* the overloaded choice function may want to communicate to the loop that it * should finish the process. */ SearchIO.output("Choice received a STOP request", 4); host.GenerationStatus[ruleSetIndex] = GenerationStatuses.Choice; ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.Choice); continue; } if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } #endregion #region ***** APPLY ***** host.saveCurrent(); foreach (var c in choice) { options[c].apply(host.graph, choose(options[c], host)); host.addToRecipe(options[c]); SearchIO.output("Rule sucessfully applied", 4); } if (Display && Rulesets[ruleSetIndex].choiceMethod == choiceMethods.Design) { SearchIO.addAndShowGraphWindow(host.graph.copy(), "After calling " + host.numRulesCalled + " rules"); } if (SearchIO.GetTerminateRequest(Thread.CurrentThread.ManagedThreadId)) { return; } #endregion #region Check to see if loop is done /* First thing we do is reduce the number of calls left. Note that if you start with * a negative number, the process will continue to make it more negative - mimicking * no cycle limit. It is safer to use the globalvar, maxRulesToApply though.*/ if (this is LindenmayerChooseRCA) { numOfCallsLeft[ruleSetIndex]--; } else { numOfCallsLeft[ruleSetIndex] = numOfCallsLeft[ruleSetIndex] - choice.GetLength(0); } if (choice.Any(c => (options[c].ruleNumber == Rulesets[ruleSetIndex].TriggerRuleNum))) { /* your ruleset loops until a trigger rule and the trigger rule was just called. */ SearchIO.output("The trigger rule has been chosen.", 4); host.GenerationStatus[ruleSetIndex] = GenerationStatuses.TriggerRule; ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.TriggerRule); } else { /* Normal operation */ SearchIO.output("RCA loop executed normally.", 4); host.GenerationStatus[ruleSetIndex] = GenerationStatuses.Normal; ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.Normal); } #endregion } }