public void setUpGraphElementAddButtons()
{
var dic = new ResourceDictionary();
try
{
dic.Source = new Uri(GSApp.settings.WorkingDirAbsolute + GSApp.settings.CustomShapesFile,
UriKind.Absolute);
}
catch
{
SearchIO.output("Custom Shapes File was not found or is invalid.");
}
foreach (string k in dic.Keys)
{
if (!Application.Current.Resources.Contains(k))
{
Application.Current.Resources.Add(k, XamlWriter.Save(dic[k]));
}
}
var dtNIS = (DataTemplate)Application.Current.Resources["NodeIconShape"];
var dtNHS = (DataTemplate)Application.Current.Resources["HyperArcIconShape"];
var dtAddBtn = (DataTemplate)Application.Current.Resources["AddButtonTemplate"];
NodeAddToolbar.Items.Clear();
ArcAddToolbar.Items.Clear();
HyperAddToolbar.Items.Clear();
SelectedAddItems = new List <string>();
SelectedAddItems.Add("");
var shortCutKeysList = new List <Key>();
shortCutKeysList.Add(Key.Escape);
var temp = (Button)dtAddBtn.LoadContent();
var imageLength = temp.Width - 8;
foreach (object key in Application.Current.Resources.Keys)
{
var keyString = key as string;
try
{
var b = (Button)dtAddBtn.LoadContent();
var s = (Shape)MyXamlHelpers.Parse((string)Application.Current.Resources[key]);
var scStr = "";
if (s.Tag != null)
{
scStr = s.Tag.ToString().Split(new[] { ':' })[0];
}
var scKey = findShortCut(ref scStr);
shortCutKeysList.Add(scKey);
SelectedAddItems.Add(keyString);
b.Name = keyString;
b.Click += AddNodeArcButton_Click;
b.MouseDoubleClick += AddNodeArcButton_DoubleClick;
if (keyString.ToLowerInvariant().Contains("node"))
{
var NIS = (Shape)dtNIS.LoadContent();
var NISsize = new Size(NIS.Width, NIS.Height);
var scale = imageLength / Math.Max(s.Height, NISsize.Height);
s.Height *= scale;
s.Width *= scale;
NIS.Height *= scale;
NIS.Width *= scale;
s.VerticalAlignment = NIS.VerticalAlignment = VerticalAlignment.Top;
NIS.Margin = new Thickness(0, (s.Height - NIS.Height) / 2, 0, 0);
b.Tag = scKey;
for (var i = 0; i <= NodeAddToolbar.Items.Count; i++)
{
if (i == NodeAddToolbar.Items.Count)
{
NodeAddToolbar.Items.Add(b);
break;
}
else if ((int)scKey < (int)((Key)((Button)NodeAddToolbar.Items[i]).Tag))
{
NodeAddToolbar.Items.Insert(i, b);
break;
}
}
((TextBlock)((Grid)b.Content).Children[0]).Text = scStr;
((TextBlock)((Grid)b.Content).Children[1]).Text = keyString;
((Grid)b.Content).Children.Insert(0, s);
((Grid)b.Content).Children.Insert(1, NIS);
}
else if (keyString.ToLowerInvariant().Contains("arc"))
{
((TextBlock)((Grid)b.Content).Children[0]).Text = scStr;
((TextBlock)((Grid)b.Content).Children[1]).Text = keyString;
s.VerticalAlignment = VerticalAlignment.Top;
Grid.SetRow(s, 0);
((Grid)b.Content).Children.Add(s);
if (s as Path != null)
{
var pathGeo = ((Path)s).Data;
if (pathGeo.IsFrozen)
{
pathGeo = pathGeo.Clone();
}
var scale = imageLength /
Math.Max(pathGeo.Bounds.Height, pathGeo.Bounds.Width);
pathGeo.Transform = new ScaleTransform(scale, scale);
}
else
{
s.Height = s.Width = imageLength;
}
b.Tag = scKey;
for (var i = 0; i <= ArcAddToolbar.Items.Count; i++)
{
if (i == ArcAddToolbar.Items.Count)
{
ArcAddToolbar.Items.Add(b);
break;
}
else if ((int)scKey < (int)((Key)((Button)ArcAddToolbar.Items[i]).Tag))
{
ArcAddToolbar.Items.Insert(i, b);
break;
}
}
}
else if (keyString.ToLowerInvariant().Contains("hyper"))
{
((TextBlock)((Grid)b.Content).Children[0]).Text = scStr;
((TextBlock)((Grid)b.Content).Children[1]).Text = keyString;
s.VerticalAlignment = VerticalAlignment.Top;
Grid.SetRow(s, 0);
((Grid)b.Content).Children.Add(s);
if (s as Path != null)
{
var pathGeo = ((Path)s).Data;
if (pathGeo.IsFrozen)
{
pathGeo = pathGeo.Clone();
}
var scale = imageLength /
Math.Max(pathGeo.Bounds.Height, pathGeo.Bounds.Width);
pathGeo.Transform = new ScaleTransform(scale, scale);
}
else
{
s.Height = s.Width = imageLength;
}
b.Tag = scKey;
for (var i = 0; i <= HyperAddToolbar.Items.Count; i++)
{
if (i == HyperAddToolbar.Items.Count)
{
HyperAddToolbar.Items.Add(b);
break;
}
else if ((int)scKey < (int)((Key)((Button)HyperAddToolbar.Items[i]).Tag))
{
HyperAddToolbar.Items.Insert(i, b);
break;
}
}
}
}
catch
{
SearchIO.output(keyString + " did not load correctly");
}
}
shortCutKeys = shortCutKeysList.ToArray();
}
/// <summary>
/// Sets up graph layout menu. It would have been better to use the .NET 3.5 pipeline approach
/// to add-ins. Was I just lazy? I tried to figure it out for 2 whole weeks. It involves up to 7
/// projects and would require GraphGUI to be serialized. However, my view of graph layout is
/// to make quick changes to postion of nodes (perhaps specific ones may change shapes and back-
/// ground but these will be few). Seeing as how XamlWriter and XamlReader are slow and bottleneck
/// the entire application, I thought simply to take this approach. All graph layouts will need
/// to be in the GraphSynth.GraphLayout assembly and be derived from the GraphLayoutBaseClass. Each
/// one found will be given a slot on the layout menu.
/// </summary>
public void setUpGraphLayoutMenu()
{
SearchIO.output("Setting Up Graph Layout Algorithms");
var keyNumOffset = (int)Key.D0;
var k = 0;
GraphLayoutAlgorithms = new List <Type>();
GraphLayoutCommands = new List <RoutedUICommand>();
GraphLayoutSubMenu.Items.Clear();
var potentialAssemblies = getPotentialAssemblies(GSApp.settings.GraphLayoutDirAbs);
if (potentialAssemblies.Count == 0)
{
return;
}
foreach (string filepath in potentialAssemblies)
{
Assembly GraphLayoutAssembly = null;
try
{
GraphLayoutAssembly = Assembly.LoadFrom(filepath);
var layouts = GraphLayoutAssembly.GetTypes();
foreach (Type lt in layouts)
{
if (!lt.IsAbstract && GraphLayoutBaseClass.IsInheritedType(lt) &&
!GraphLayoutAlgorithms.Any(w => w.FullName.Equals(lt.FullName)))
{
var newLayAlgo = GraphLayoutBaseClass.Make(lt);
if (newLayAlgo != null)
{
try
{
KeyGesture kg = null;
if (k < 10)
{
kg = new KeyGesture((Key)(k + keyNumOffset), ModifierKeys.Alt);
}
else if (k < 20)
{
kg = new KeyGesture((Key)(k + keyNumOffset - 10),
ModifierKeys.Alt | ModifierKeys.Shift);
}
else if (k < 30)
{
kg = new KeyGesture((Key)(k + keyNumOffset - 20),
ModifierKeys.Control | ModifierKeys.Alt |
ModifierKeys.Shift);
}
else
{
MessageBox.Show(
"No shortcut has been assigned to " + newLayAlgo.text +
". That sure is an awful lot "
+
" of graph layout algorithms! Consider reducing the number included in the plugins directory",
"No ShortCut Assigned", MessageBoxButton.OK);
}
GraphLayoutAlgorithms.Add(lt);
var newGLCommand = new RoutedUICommand(newLayAlgo.text, lt.Name,
GetType(),
new InputGestureCollection {
kg
});
GraphLayoutCommands.Add(newGLCommand);
CommandBindings.Add(new CommandBinding(newGLCommand, GraphLayoutOnExecuted,
GraphLayoutCanExecute));
GraphLayoutSubMenu.Items.Add(new MenuItem {
Command = newGLCommand
});
SearchIO.output("\t" + lt.Name + " loaded successfully.");
k++;
}
catch (Exception exc)
{
SearchIO.output("Unable to load " + lt.Name + ": " + exc.Message);
}
}
}
}
}
catch
{
// File was either not found are not of the right type.
}
}
if (Directory.Exists(GSApp.settings.GraphLayoutDirAbs))
{
glWatcher = new FileSystemWatcher(GSApp.settings.GraphLayoutDirAbs, "*.dll");
glWatcher.Changed += GraphLayoutDir_Changed;
glWatcher.Created += GraphLayoutDir_Changed;
glWatcher.Deleted += GraphLayoutDir_Changed;
glWatcher.Renamed += GraphLayoutDir_Changed;
glWatcher.EnableRaisingEvents = true;
glWatcher.IncludeSubdirectories = true;
glWatcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName;
}
}
public void setUpSearchProcessMenu()
{
SearchIO.output("Setting Up Search Process Algorithms");
var k = 0;
SearchCommands = new List <RoutedUICommand>();
SearchAlgorithms = new List <SearchProcess>();
while (DesignDropDown.Items.Count > 14)
{
DesignDropDown.Items.RemoveAt(14);
}
var potentialAssemblies = getPotentialAssemblies(GSApp.settings.SearchDirAbs);
potentialAssemblies.Add("thisEXE");
foreach (string filepath in potentialAssemblies)
{
Assembly searchAssembly = null;
try
{
if (filepath == "thisEXE")
{
searchAssembly = Assembly.GetExecutingAssembly();
}
else
{
searchAssembly = Assembly.LoadFrom(filepath);
}
var searchprocesses = searchAssembly.GetTypes();
foreach (Type spt in searchprocesses)
{
if (!spt.IsAbstract && SearchProcess.IsInheritedType(spt) &&
!SearchAlgorithms.Any(w => w.GetType().FullName.Equals(spt.FullName)))
{
try
{
var constructor = spt.GetConstructor(new Type[0]);
var searchAlgo = (SearchProcess)constructor.Invoke(null);
searchAlgo.settings = GSApp.settings;
KeyGesture kg = null;
if (k < endOfFKeys)
{
kg = new KeyGesture((Key)(k + keyNumOffset), ModifierKeys.None);
}
else if (k < 2 * endOfFKeys)
{
kg = new KeyGesture((Key)(k + keyNumOffset - endOfFKeys), ModifierKeys.Shift);
}
else if (k < 3 * endOfFKeys)
{
kg = new KeyGesture((Key)(k + keyNumOffset - 2 * endOfFKeys),
ModifierKeys.Control | ModifierKeys.Shift);
}
else
{
MessageBox.Show(
"No shortcut has been assigned to " + searchAlgo.text +
". That sure is an awful lot "
+
" of search process algorithms! Consider reducing the number included in the plugins directory",
"No ShortCut Assigned", MessageBoxButton.OK);
}
SearchAlgorithms.Add(searchAlgo);
var newSearchCommand = new RoutedUICommand(searchAlgo.text, spt.Name,
GetType(), new InputGestureCollection {
kg
});
SearchCommands.Add(newSearchCommand);
CommandBindings.Add(new CommandBinding(newSearchCommand, RunSearchProcessOnExecuted,
RunSearchProcessCanExecute));
DesignDropDown.Items.Add(new MenuItem {
Command = newSearchCommand
});
k++;
SearchIO.output("\t" + spt.Name + " loaded successfully.");
}
catch (Exception exc)
{
SearchIO.output("Unable to load " + spt.Name + ": " + exc.Message);
}
}
}
}
catch (Exception exc)
{
if (searchAssembly == null)
{
SearchIO.output("Unable to open " + filepath + ": " + exc.Message);
}
else
{
SearchIO.output("Unable to open " + searchAssembly.FullName + "(" + filepath + "): " +
exc.Message);
}
}
}
if (Directory.Exists(GSApp.settings.SearchDirAbs))
{
sWatcher = new FileSystemWatcher(GSApp.settings.SearchDirAbs, "*.dll");
sWatcher.Changed += SearchDir_Changed;
sWatcher.Created += SearchDir_Changed;
sWatcher.Deleted += SearchDir_Changed;
sWatcher.Renamed += SearchDir_Changed;
sWatcher.EnableRaisingEvents = true;
sWatcher.IncludeSubdirectories = true;
sWatcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite
| NotifyFilters.FileName;
}
}
static void Main()
{
/* first a new optimization method in the form of a genetic algorithm is created. */
var optMethod = new MultiObjectiveGeneticAlgorithm();
/* The objective function is Rosenbrock's banana function again. */
optMethod.Add(new polynomialObjFn
{
Terms = new List <string>
{
"100*x1^4",
"-200*x1^2*x2",
"x1^2",
"-2*x1",
"100*x2^2",
"1"
}
});
optMethod.Add(new RoyalRoads());
/* Now a number of convergerence criteria are added. Again, since these all
* inherit from the abstractConvergence class, the Add method knows to where
* to store them. */
optMethod.Add(new MaxIterationsConvergence(50000)); /* stop after 500 iteration (i.e. generations) */
optMethod.Add(new MaxAgeConvergence(20, 0.000000001)); /*stop after 20 generations of the best not changing */
optMethod.Add(new MaxSpanInPopulationConvergence(100)); /*stop if the largest distance is only one unit. */
optMethod.NumConvergeCriteriaNeeded = 2; /* two of these three criteria are needed to stop the process. */
/* The genetic algorithm is for discrete problems. Therefore we need to provide the optimization algorithm
* and the subsequent generators with the details of the space. The first variable represents the number of
* passes in our fictitious problem. We set the lower bound to 1 and the upper bound to 20. The third argument
* is the delta and since only integers are possible we set this to 1. The second and third variables are
* really continous, but for the purpose of the GA we set a discretization at one-ten-thousandth for the second
* and one-hundredth in the third. Note that you can provide either the delta or the number of steps. Here
* 36,001 steps will make increments of one-hundredth. */
var SpaceDescriptor = new DesignSpaceDescription
{
new VariableDescriptor(-100, 100, 0.0001),
new VariableDescriptor(-100, 100, 0.0001),
new VariableDescriptor(-100, 100, 0.0001)
};
optMethod.Add(SpaceDescriptor);
/* the genetic algorithm requires some more values to be fully specified. These include initial,
* crossover, and mutation generators, as well as a selector. A Latin Hyper Cube initial sample is
* first created to assure the population covers the space well. */
optMethod.Add(new LatinHyperCube(SpaceDescriptor, VariablesInScope.BothDiscreteAndReal));
/* the typical bit-string approach to mutation and crossover are adopted here. Note that the
* mutation rate (per candidate) is increased to 0.4 from the default of 0.1. Which means that
* 4 in 10 candidates should experience at least one mutation. No new crossover rate is provided
* therefore the default of 1.7 will be used. This means that between two parents there will likely
* be 1.7 locations of crossover between them. */
optMethod.Add(new GAMutationBitString(SpaceDescriptor, 0.4));
optMethod.Add(new GACrossoverBitString(SpaceDescriptor));
/* Finally, the selector is added to the population. This RandomPairwiseCompare is often referred to
* as tournament selection wherein a random selection of two candidates results in the inferior one
* being removed from the population. It requires the optimization direction: are lower values better
* (minimize) or larger (maximize)? */
optMethod.Add(new SkewboidDiversity(optimize.minimize, optimize.minimize));
optMethod.Add(new RandomPairwiseCompare(optimize.minimize));
/* for output statements (points in the code where the SearchIO.output(...) function is called, the
* verbosity is set to 4 which is high. Typical values are between 0 and 4 but higher values (>4)
* may be used, but this will likely cut into the speed of the search process. */
Parameters.Verbosity = VerbosityLevels.AboveNormal;
/* everything is set, we can now run the algorithm and retrieve the f* and x* values. */
double[] xOptimal;
var fOptimal = optMethod.Run(out xOptimal);
/* since we are curious how the process completed we now output some details. */
SearchIO.output("f* = " + fOptimal); /* the 0 indicates that this statement has high priority
* and shouldn't be skipped in printing to the console. */
SearchIO.output("x* = " + xOptimal.MakePrintString());
SearchIO.output("The process converged by criteria: " + optMethod.ConvergenceDeclaredByTypeString);
Console.ReadLine();
}
/* 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).*/
public void RecognizeChooseApplyCycle(candidate host, int ruleSetIndex, int[] numOfCallsLeft)
{
while ((ruleSetIndex >= 0) && (ruleSetIndex < numOfRuleSets))
{
host.activeRuleSetIndex = ruleSetIndex;
SearchIO.output("Active Rule Set = " + ruleSetIndex.ToString(), 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.ToString(), 4);
List <option> options = rulesets[ruleSetIndex].recognize(host.graph);
SearchIO.output("There are " + options.Count.ToString() + " rule choices.", 4);
if (options.Count == 0)
{
/* There are no rules to recognize, exit here. */
host.GenerationStatus[ruleSetIndex] = GenerationStatuses.NoRules;
ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.NoRules);
continue;
}
if (SearchIO.terminateRequest)
{
return;
}
#endregion
#region ***** CHOOSE *****
if (rulesets[ruleSetIndex].choiceMethod == choiceMethods.Automatic)
{
choice = 0;
}
else
{
choice = choose(options, host);
}
SearchIO.output("Choice = #" + choice.ToString(), 4);
if (choice == -1)
{
host.undoLastRule();
if (display)
{
SearchIO.addAndShowGraphDisplay(host.graph.copy(),
"Revert to after calling " + host.numRulesCalled + " rules");
}
continue;
}
if ((choice < 0) || (choice >= options.Count))
{
/* 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.terminateRequest)
{
return;
}
#endregion
#region ***** APPLY *****
host.saveCurrent();
options[choice].apply(host.graph, choose(options[choice], host));
host.addToRecipe(options[choice]);
SearchIO.output("Rule sucessfully applied", 4);
/* display state? */
if (display)
{
SearchIO.addAndShowGraphDisplay(host.graph.copy(),
"After calling " + host.numRulesCalled + " rules");
}
if (SearchIO.terminateRequest)
{
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.*/
numOfCallsLeft[ruleSetIndex]--;
/* a significant change is made here in Version 1.1.2.0, it is actually the removal of
* code. We were checking the numOfCallsLeft here as well as the top, but it has been decided
* that it is ambiguous to check in both locations. Later, it may be determined that two
* independent cycle limits need to be imposed, but in the mean time, the following code will be
* commented out.
* if (numOfCallsLeft[ruleSetIndex] == 0)
* { /* there of no more calls on this ruleset allowed, the limit has been reached.
* SearchIO.output("The maximum num of calls has been reached", 4);
* host.GenerationStatus[ruleSetIndex] = GenerationStatuses.CycleLimit;
* ruleSetIndex = nextRuleSet(ruleSetIndex, GenerationStatuses.CycleLimit);
* }
* else */
if (options[choice].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
}
}
private static void Main()
{
Parameters.Verbosity = VerbosityLevels.AboveNormal;
// this next line is to set the Debug statements from OOOT to the Console.
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
/* In this example, we first present how the details of an optimzation
* problem can be saved to an XML-file so that it can be read in
* and solved as opposed to defining all the details in an imperative
* (code line by code line) way. In the first function, the xml file
* name "test1.xml" is created. */
makeAndSaveProblemDefinition();
/* now we create a series of different optimization methods and test
* them on the problem. The problem is now opened from the file and
* the details are stored in an object of class "Problem Definition".*/
var stream = new FileStream(filename, FileMode.Open);
ProblemDefinition probTest1 = ProblemDefinition.OpenprobFromXml(stream);
abstractOptMethod opty;
/***********Gradient Based Optimization with Steepest Descent****************/
SearchIO.output("***********Gradient Based Optimization with Steepest Descent****************");
opty = new GradientBasedOptimization();
opty.Add(probTest1);
abstractSearchDirection searchDirMethod = new SteepestDescent();
opty.Add(searchDirMethod);
//abstractLineSearch lineSearchMethod = new ArithmeticMean(0.0001, 1, 100);
//abstractLineSearch lineSearchMethod = new DSCPowell(0.0001, 1, 100);
abstractLineSearch lineSearchMethod = new GoldenSection(0.0001, 1);
opty.Add(lineSearchMethod);
opty.Add(new squaredExteriorPenalty(opty, 10));
/* since this is not a population-based optimization method, we need to remove the MaxSpan criteria. */
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
double[] xStar;
var timer = Stopwatch.StartNew();
var fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/***********Gradient Based Optimization with Fletcher-Reeves****************/
SearchIO.output("***********Gradient Based Optimization with Fletcher-Reeves****************");
/* we don't need to reset (invoke the constructor) for GradientBasedOptimization since we are only
* change the seaach direction method. */
searchDirMethod = new FletcherReevesDirection();
/* you could also try the remaining 3 search direction methods. */
//searchDirMethod = new CyclicCoordinates();
//searchDirMethod = new BFGSDirection();
//searchDirMethod = new PowellMethod(0.001, 6);
opty.Add(searchDirMethod);
timer = Stopwatch.StartNew();
opty.ResetFunctionEvaluationDatabase();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Generalized Reduced Gradient***********************/
SearchIO.output("******************Generalized Reduced Gradient***********************");
opty = new GeneralizedReducedGradientActiveSet();
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 10));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/* GRG is the ONLY one here that handles constraints explicity. It find the
* optimal very quickly and accurately. However, many of the other show a
* better value of f*, this is because they are using an imperfect penalty
* function (new squaredExteriorPenalty(opty, 10)). While it seems that GRG
* includes it as well, it is only used in the the line search method. */
/******************Random Hill Climbing ***********************/
SearchIO.output("******************Random Hill Climbing ***********************");
opty = new HillClimbing();
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 8));
opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor));
opty.Add(new KeepSingleBest(optimize.minimize));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
/* the deltaX convergence needs to be removed as well, since RHC will end many iterations
* at the same point it started. */
opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Exhaustive Hill Climbing ***********************/
SearchIO.output("******************Exhaustive Hill Climbing ***********************");
/* Everything else about the Random Hill Climbing stays the same. */
opty.Add(new ExhaustiveNeighborGenerator(probTest1.SpaceDescriptor));
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Simulated Annealing***********************/
SearchIO.output("******************Simulated Annealing***********************");
opty = new SimulatedAnnealing(optimize.minimize);
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 10));
opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor, 100));
opty.Add(new SACoolingSangiovanniVincentelli(100));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
/* the deltaX convergence needs to be removed as well, since RHC will end many iterations
* at the same point it started. */
opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Exhaustive Search ***********************/
// SearchIO.output("******************Exhaustive Search ***********************");
//opty = new ExhaustiveSearch(probTest1.SpaceDescriptor, optimize.minimize);
//opty.Add(probTest1);
/* No convergence criteria is needed as the process concludes when all
* states have been visited but for this problem that is 4 trillion states.*/
//opty.ConvergenceMethods.Clear();
/* if you DID KNOW the best, you can include a criteria like...*/
//opty.ConvergenceMethods.Add(new ToKnownBestXConvergence(new[] { 3.0, 3.0 }, 0.0000001));
//timer = Stopwatch.StartNew();
//fStar = opty.Run(out xStar);
/* you probably will never see this process complete. Even with the added
* convergence criteria (which is not factored into the estimated time of
* completion), you are probably looking at 1 to 2 years. */
//printResults(opty, xStar, fStar, timer);
}
public void evalGT(candidate c)
{
current = c;
reorderNodes(c);
Boolean found = false;
/* recall that gearcount is found in reorderNodes, Albert! */
stateVars = new double[gearcount + 1, 10];
#region Set up optMethod
//NelderMead optMethod =
// new NelderMead(.001, 10, true);
//GradientBasedUnconstrained optMethod =
// new GradientBasedUnconstrained(10);
GradientBasedOptimization optMethod = new GradientBasedOptimization(10);
//SequentialQuadraticProgramming optMethod = new SequentialQuadraticProgramming(true);
//GeneralizedReducedGradientActiveSet optMethod =
// new GeneralizedReducedGradientActiveSet(true);
optMethod.Add(new ArithmeticMean(optMethod, 0.001, 2, 200));
//optMethod.Add(new GoldenSection(optMethod, 0.001,200, int.MaxValue));
//optMethod.Add(new BFGSDirection());
optMethod.Add(new FletcherReevesDirection());
optMethod.Add(new convergenceBasic(BasicConvergenceTypes.OrBetweenSetConditions, 200, 0.0001, double.NaN, double.NaN, int.MaxValue));
//optMethod.Add(new convergenceBasic(BasicConvergenceTypes.AndBetweenSetConditions, 20, 0.01, double.NaN, double.NaN, int.MaxValue));
optMethod.Add(new squaredExteriorPenalty(optMethod, 10.0));
//optMethod.Add(new linearExteriorPenaltySum(optMethod, 10.0));
DiscreteSpaceDescriptor dsd = new DiscreteSpaceDescriptor(optMethod, 4 * gearcount);
optMethod.Add(dsd);
#endregion
for (int i = 0; i < gearcount; i++)
{
foreach (GearFamily gf in gearFamilies)
{
if (c.graph.nodes[i].localLabels.Contains(gf.label))
{
for (int j = 0; j < 3; j++)
{
if (c.graph.nodes[i].localVariables.Count < j + 1)
{
c.graph.nodes[i].localVariables.Add(double.NaN);
}
}
c.graph.nodes[i].localVariables[0] = gf.Sfb;
c.graph.nodes[i].localVariables[1] = gf.Sfc;
c.graph.nodes[i].localVariables[2] = gf.density;
dsd.addLinkedVariableValues(new int[] { 4 * i, 4 * i + 1, 4 * i + 2 }, gf.gears);
}
}
}
SearchIO.output("The parametric space is " + dsd.SizeOfSpace.ToString(), 3);
//setup constraints for optimization
//slot 1 - number of teeth
//slot 2 - pitch
//slot 3 - face Width
//slot 4 - location variable
#region Constraint Building Region
double[] x = new double[4 * gearcount];
double[] xStar = new double[4 * gearcount];
//double fStar = double.PositiveInfinity;
double fStar = 0.0;
double ftemp = 1000;
double weightstar = 100;
double lowestmass = 100;
double massstar = 100;
double mass = 100;
double[,] stateVarsStar = new double[gearcount + 1, 10];
outputSpeedConstraint oSC =
new outputSpeedConstraint(stateVars, this);
optMethod.Add(oSC);
stressConstraint sc =
new stressConstraint(stateVars, c, this);
optMethod.Add(sc);
boundingboxConstraint bbc =
new boundingboxConstraint(stateVars, c, this);
optMethod.Add(bbc);
outputLocationConstraint olc =
new outputLocationConstraint(stateVars, c, this);
optMethod.Add(olc);
List <samePitch> samePitches = new List <samePitch>();
for (int i = 0; i < gearcount; i++)
{
if ((c.graph.nodes[i].localLabels.Contains("contact")) || (c.graph.nodes[i].localLabels.Contains("bevelcontact")) || (c.graph.nodes[i].localLabels.Contains("wormcontact")))
{
samePitches.Add(new samePitch(((i - 1) * 4) + 1, ((i * 4) + 1)));
}
}
f = new totalObjFunction(this, current, stateVars);
optMethod.Add(f);
#endregion
int numVars = dsd.linkedSpace.Count;
int[] VarIndices = new int[numVars];
for (int i = 0; i < numVars; i++)
{
VarIndices[i] = 0;
}
int[] VarMaxes = new int[numVars];
for (int i = 0; i < numVars; i++)
{
VarMaxes[i] = dsd.linkedSpace[i].GetLength(0);
}
int currentI = 0;
VarIndices[currentI]--; //this is an unavoidable hack to start at all zeroes.
do
{
VarIndices[currentI]++;
if (VarIndices[currentI] == VarMaxes[currentI])
{
VarIndices[currentI] = 0;
currentI++;
if ((currentI > numVars - 3) && (currentI < numVars))
{
SearchIO.output("Index " + currentI.ToString() + " changed to " + VarIndices[currentI].ToString(), 4);
}
}
else
{
currentI = 0;
x = dsd.GetDesignVector(null, VarIndices);
//fStar = f.calculate(x);
Boolean Feasible = true;
foreach (samePitch sp in samePitches)
{
if (!sp.feasible(x))
{
Feasible = false;
}
}
if (Feasible && oSC.feasible(x))
{
if (sc.feasible(x))
{
//run optMethod here
double[] xTuned;
mass = 0;
double fTuned = optMethod.run(x, out xTuned);
for (int k = 0; k < gearcount; k++)
{
mass += stateVars[k, 2];
}
found = false;
if (fTuned < ftemp)
{
ftemp = fTuned;
}
found = isCurrentTheGoal(stateVars, udg);
if (found == true)
{
if (mass < massstar)
{
fStar = fTuned;
xStar = (double[])xTuned.Clone();
massstar = mass;
stateVarsStar = (double[, ])stateVars.Clone();
}
}
}
}
}
} while (currentI < numVars);
SearchIO.output("final report f = " + c.f0, 3);
if (gearcount > 2)
{
if (massstar == 100)
{
fStar = ftemp + 50;
}
}
c.f0 = fStar;
c.f2 = massstar;
c.f1 = calcInefficiency(stateVarsStar);
string outputString = "";
string outputString2 = "";
double p = 0;
for (int i = 0; i < gearcount; i++)
//var order
//x, y, z, vx, vy, vz, face width, diameter, number of teeth, type ID number
{//output for gear visualizer!
outputString += "gear," + (i + 1) + "," + stateVarsStar[i, 3] + "," + stateVarsStar[i, 4] +
"," + stateVarsStar[i, 5] + "," + stateVarsStar[i, 6] + "," + stateVarsStar[i, 7] + "," +
stateVarsStar[i, 8] + "," + xStar[i * 4 + 2] + "," + (xStar[i * 4] / xStar[i * 4 + 1]) +
"," + xStar[i * 4] + "," + stateVarsStar[i, 9] + "\n";
if (i != 0)
{
if ((stateVarsStar[i, 3] - stateVarsStar[(i - 1), 3] == 0) && (stateVarsStar[i, 4] - stateVarsStar[(i - 1), 4] == 0))
{
outputString2 += "rod," + (p) + "," + i + "," + (i - 1);//(stateVarsStar[i, 5] - stateVarsStar[(i - 1), 5]);
p += 1;
}
}
for (int j = 1; j < 9; j++)
{
if (c.graph.nodes[i].localVariables.Count <= j)
{
c.graph.nodes[i].localVariables.Add(double.NaN);
}
}
c.graph.nodes[i].localVariables[3] = stateVarsStar[i, 3];
c.graph.nodes[i].localVariables[4] = stateVarsStar[i, 4];
c.graph.nodes[i].localVariables[5] = stateVarsStar[i, 5];
c.graph.nodes[i].localVariables[6] = stateVarsStar[i, 6];
c.graph.nodes[i].localVariables[7] = stateVarsStar[i, 7];
c.graph.nodes[i].localVariables[8] = stateVarsStar[i, 8];
}
for (int j = 1; j < 9; j++)
{
if (c.graph.nodes[gearcount].localVariables.Count <= j)
{
c.graph.nodes[gearcount].localVariables.Add(double.NaN);
}
}
c.graph.nodes[gearcount].localVariables[3] = stateVarsStar[gearcount, 3];
c.graph.nodes[gearcount].localVariables[4] = stateVarsStar[gearcount, 4];
c.graph.nodes[gearcount].localVariables[5] = stateVarsStar[gearcount, 5];
c.graph.nodes[gearcount].localVariables[6] = stateVarsStar[gearcount, 6];
c.graph.nodes[gearcount].localVariables[7] = stateVarsStar[gearcount, 7];
c.graph.nodes[gearcount].localVariables[8] = stateVarsStar[gearcount, 8];
string filename = Program.settings.outputDirectory + "visualizerOutput1.txt";
FileStream fs = new FileStream(filename, FileMode.Create);
StreamWriter outputWriter = new StreamWriter(fs);
outputWriter.WriteLine(outputString);
outputWriter.WriteLine(outputString2);
outputWriter.Close();
fs.Close();
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
string filename;
try
{
filename = getOpenFilename(Program.settings.workingDirectory);
}
catch { filename = ""; }
if (filename != "" && filename != null)
{
/* Load the file. */
XmlDocument doc = new XmlDocument();
doc.Load(filename);
/* create prefix<->namespace mappings (if any) */
XmlNamespaceManager nsMgr = new XmlNamespaceManager(doc.NameTable);
/* Query the document */
if (doc.SelectNodes("/grammarRule", nsMgr).Count > 0)
{
grammarRule rule = grammarRule.openRuleFromXml(filename);
grammarDisplays.Add(new grammarRuleDisplay(rule, Path.GetFileName(filename)));
grammarDisplays[grammarChildCount].Show();
}
else if (doc.SelectNodes("/ruleSet", nsMgr).Count > 0)
{
ruleSet rs = ruleSet.openRuleSetFromXml(filename, Program.settings.defaultGenSteps);
ruleSetDisplays.Add(new ruleSetDisplay(rs, Path.GetFileName(filename)));
ruleSetDisplays[ruleSetChildCount].Show();
}
else if (doc.SelectNodes("/designGraph", nsMgr).Count > 0)
{
designGraph graph = designGraph.openGraphFromXml(filename);
addAndShowGraphDisplay(graph, Path.GetFileName(filename));
}
else if (doc.SelectNodes("/candidate", nsMgr).Count > 0)
{
string tempString = "";
candidate c = candidate.openCandidateFromXml(filename);
SearchIO.output("The candidate found in " + filename, 0);
if (c.performanceParams.Count > 0)
{
tempString = "has the following performance parameters";
foreach (double a in c.performanceParams)
{
tempString += ": " + a.ToString();
}
SearchIO.output(tempString, 0);
}
if (c.age > 0)
{
SearchIO.output("The candidate has existed for " + c.age.ToString() + " iterations.", 0);
}
SearchIO.output("It's generation ended in RuleSet #" + c.activeRuleSetIndex.ToString(), 0);
tempString = "Generation terminated with";
foreach (GenerationStatuses a in c.GenerationStatus)
{
tempString += ": " + a.ToString();
}
SearchIO.output(tempString, 0);
addAndShowGraphDisplay(c.graph, "Candidate in " + Path.GetFileName(filename));
}
else
{
MessageBox.Show("The XML files that you have attempted to open contains an unknown" +
"type (not designGraph, grammarRule, ruleSet, or candidate).", "XML Serialization Error",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
