Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Tests/HeuristicLab-3.3/SamplesTest.cs @ 8986

Last change on this file since 8986 was 8906, checked in by svonolfe, 12 years ago

Adapted VRP test to changes of r8905 (#1981)
File size: 60.6 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Linq;
24using System.Threading;
25using HeuristicLab.Algorithms.DataAnalysis;
26using HeuristicLab.Algorithms.EvolutionStrategy;
27using HeuristicLab.Algorithms.GeneticAlgorithm;
28using HeuristicLab.Algorithms.LocalSearch;
29using HeuristicLab.Algorithms.ParticleSwarmOptimization;
30using HeuristicLab.Algorithms.RAPGA;
31using HeuristicLab.Algorithms.ScatterSearch;
32using HeuristicLab.Algorithms.SimulatedAnnealing;
33using HeuristicLab.Algorithms.TabuSearch;
34using HeuristicLab.Algorithms.VariableNeighborhoodSearch;
35using HeuristicLab.Data;
36using HeuristicLab.Encodings.BinaryVectorEncoding;
37using HeuristicLab.Encodings.PermutationEncoding;
38using HeuristicLab.Encodings.RealVectorEncoding;
39using HeuristicLab.Encodings.ScheduleEncoding.JobSequenceMatrix;
40using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
41using HeuristicLab.Optimization;
42using HeuristicLab.Optimization.Operators;
43using HeuristicLab.ParallelEngine;
44using HeuristicLab.Persistence.Default.Xml;
45using HeuristicLab.Problems.ArtificialAnt;
46using HeuristicLab.Problems.DataAnalysis;
47using HeuristicLab.Problems.DataAnalysis.Symbolic;
48using HeuristicLab.Problems.DataAnalysis.Symbolic.Classification;
49using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
50using HeuristicLab.Problems.Instances;
51using HeuristicLab.Problems.Instances.DataAnalysis;
52using HeuristicLab.Problems.Instances.TSPLIB;
53using HeuristicLab.Problems.Instances.VehicleRouting;
54using HeuristicLab.Problems.Knapsack;
55using HeuristicLab.Problems.Scheduling;
56using HeuristicLab.Problems.TestFunctions;
57using HeuristicLab.Problems.TravelingSalesman;
58using HeuristicLab.Problems.VehicleRouting;
59using HeuristicLab.Problems.VehicleRouting.Encodings.General;
60using HeuristicLab.Problems.VehicleRouting.Encodings.Potvin;
61using HeuristicLab.Problems.VehicleRouting.ProblemInstances;
62using HeuristicLab.Selection;
63using HeuristicLab.SequentialEngine;
64using Microsoft.VisualStudio.TestTools.UnitTesting;
65
66
67namespace HeuristicLab_33.Tests {
68  [TestClass]
69  [DeploymentItem(@"HeuristicLab-3.3/Resources/C101.opt.txt")]
70  [DeploymentItem(@"HeuristicLab-3.3/Resources/C101.txt")]
71  public class SamplesTest {
72    #region GA
73    #region TSP
74    [TestMethod]
75    public void CreateGaTspSampleTest() {
76      var ga = CreateGaTspSample();
77      XmlGenerator.Serialize(ga, "../../GA_TSP.hl");
78    }
79    [TestMethod]
80    public void RunGaTspSampleTest() {
81      var ga = CreateGaTspSample();
82      ga.SetSeedRandomly.Value = false;
83      RunAlgorithm(ga);
84      Assert.AreEqual(12332, GetDoubleResult(ga, "BestQuality"));
85      Assert.AreEqual(13123.2, GetDoubleResult(ga, "CurrentAverageQuality"));
86      Assert.AreEqual(14538, GetDoubleResult(ga, "CurrentWorstQuality"));
87      Assert.AreEqual(99100, GetIntResult(ga, "EvaluatedSolutions"));
88    }
89
90    private GeneticAlgorithm CreateGaTspSample() {
91      GeneticAlgorithm ga = new GeneticAlgorithm();
92      #region Problem Configuration
93      var provider = new TSPLIBTSPInstanceProvider();
94      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
95      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
96      tspProblem.Load(provider.LoadData(instance));
97      tspProblem.UseDistanceMatrix.Value = true;
98      #endregion
99      #region Algorithm Configuration
100      ga.Name = "Genetic Algorithm - TSP";
101      ga.Description = "A genetic algorithm which solves the \"ch130\" traveling salesman problem (imported from TSPLIB)";
102      ga.Problem = tspProblem;
103      ConfigureGeneticAlgorithmParameters<ProportionalSelector, OrderCrossover2, InversionManipulator>(
104        ga, 100, 1, 1000, 0.05);
105      #endregion
106      return ga;
107    }
108    #endregion
109    #region VRP
110    [TestMethod]
111    public void CreateGaVrpSampleTest() {
112      var ga = CreateGaVrpSample();
113      XmlGenerator.Serialize(ga, "../../GA_VRP.hl");
114    }
115
116    [TestMethod]
117    public void RunGaVrpSampleTest() {
118      var ga = CreateGaVrpSample();
119      ga.SetSeedRandomly.Value = false;
120      RunAlgorithm(ga);
121      Assert.AreEqual(1828.9368669428338, GetDoubleResult(ga, "BestQuality"));
122      Assert.AreEqual(1830.1444308908331, GetDoubleResult(ga, "CurrentAverageQuality"));
123      Assert.AreEqual(1871.7128510304112, GetDoubleResult(ga, "CurrentWorstQuality"));
124      Assert.AreEqual(99100, GetIntResult(ga, "EvaluatedSolutions"));
125    }
126
127    private GeneticAlgorithm CreateGaVrpSample() {
128      GeneticAlgorithm ga = new GeneticAlgorithm();
129      #region Problem Configuration
130      VehicleRoutingProblem vrpProblem = new VehicleRoutingProblem();
131
132      SolomonFormatInstanceProvider instanceProvider = new SolomonInstanceProvider();
133      CVRPTWData data = instanceProvider.Import("C101.txt", "C101.opt.txt") as CVRPTWData;
134      vrpProblem.Load(data);
135      vrpProblem.Name = "C101 VRP (imported from Solomon)";
136      vrpProblem.Description = "Represents a Vehicle Routing Problem.";
137      CVRPTWProblemInstance instance = vrpProblem.ProblemInstance as CVRPTWProblemInstance;
138      instance.DistanceFactor.Value = 1;
139      instance.FleetUsageFactor.Value = 100;
140      instance.OverloadPenalty.Value = 100;
141      instance.TardinessPenalty.Value = 100;
142      instance.TimeFactor.Value = 0;
143      vrpProblem.MaximizationParameter.Value.Value = false;
144      instance.UseDistanceMatrix.Value = true;
145      instance.Vehicles.Value = 25;
146      #endregion
147      #region Algorithm Configuration
148      ga.Name = "Genetic Algorithm - VRP";
149      ga.Description = "A genetic algorithm which solves the \"C101\" vehicle routing problem (imported from Solomon)";
150      ga.Problem = vrpProblem;
151      ConfigureGeneticAlgorithmParameters<TournamentSelector, MultiVRPSolutionCrossover, MultiVRPSolutionManipulator>(
152        ga, 100, 1, 1000, 0.05, 3);
153
154      var xOver = (MultiVRPSolutionCrossover)ga.Crossover;
155      foreach (var op in xOver.Operators) {
156        xOver.Operators.SetItemCheckedState(op, false);
157      }
158      xOver.Operators.SetItemCheckedState(xOver.Operators
159        .OfType<PotvinRouteBasedCrossover>()
160        .Single(), true);
161      xOver.Operators.SetItemCheckedState(xOver.Operators
162        .OfType<PotvinSequenceBasedCrossover>()
163        .Single(), true);
164
165      var manipulator = (MultiVRPSolutionManipulator)ga.Mutator;
166      foreach (var op in manipulator.Operators) {
167        manipulator.Operators.SetItemCheckedState(op, false);
168      }
169      manipulator.Operators.SetItemCheckedState(manipulator.Operators
170        .OfType<PotvinOneLevelExchangeMainpulator>()
171        .Single(), true);
172      manipulator.Operators.SetItemCheckedState(manipulator.Operators
173        .OfType<PotvinTwoLevelExchangeManipulator>()
174        .Single(), true);
175      #endregion
176      return ga;
177    }
178    #endregion
179    #region ArtificialAnt
180    [TestMethod]
181    public void CreateGpArtificialAntSampleTest() {
182      var ga = CreateGpArtificialAntSample();
183      XmlGenerator.Serialize(ga, "../../SGP_SantaFe.hl");
184    }
185
186    [TestMethod]
187    public void RunGpArtificialAntSampleTest() {
188      var ga = CreateGpArtificialAntSample();
189      ga.SetSeedRandomly.Value = false;
190      RunAlgorithm(ga);
191      Assert.AreEqual(81, GetDoubleResult(ga, "BestQuality"));
192      Assert.AreEqual(48.19, GetDoubleResult(ga, "CurrentAverageQuality"));
193      Assert.AreEqual(0, GetDoubleResult(ga, "CurrentWorstQuality"));
194      Assert.AreEqual(50950, GetIntResult(ga, "EvaluatedSolutions"));
195    }
196
197    public GeneticAlgorithm CreateGpArtificialAntSample() {
198      GeneticAlgorithm ga = new GeneticAlgorithm();
199      #region Problem Configuration
200      ArtificialAntProblem antProblem = new ArtificialAntProblem();
201      antProblem.BestKnownQuality.Value = 89;
202      antProblem.MaxExpressionDepth.Value = 10;
203      antProblem.MaxExpressionLength.Value = 100;
204      antProblem.MaxFunctionArguments.Value = 3;
205      antProblem.MaxFunctionDefinitions.Value = 3;
206      antProblem.MaxTimeSteps.Value = 600;
207      #endregion
208      #region Algorithm Configuration
209      ga.Name = "Genetic Programming - Artificial Ant";
210      ga.Description = "A standard genetic programming algorithm to solve the artificial ant problem (Santa-Fe trail)";
211      ga.Problem = antProblem;
212      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeArchitectureManipulator>(
213        ga, 1000, 1, 50, 0.15, 5);
214      var mutator = (MultiSymbolicExpressionTreeArchitectureManipulator)ga.Mutator;
215      mutator.Operators.SetItemCheckedState(mutator.Operators
216        .OfType<FullTreeShaker>()
217        .Single(), false);
218      mutator.Operators.SetItemCheckedState(mutator.Operators
219        .OfType<OnePointShaker>()
220        .Single(), false);
221      mutator.Operators.SetItemCheckedState(mutator.Operators
222        .OfType<ArgumentDeleter>()
223        .Single(), false);
224      mutator.Operators.SetItemCheckedState(mutator.Operators
225        .OfType<SubroutineDeleter>()
226        .Single(), false);
227      #endregion
228      return ga;
229    }
230    #endregion
231    #region Symbolic Regression
232    [TestMethod]
233    public void CreateGpSymbolicRegressionSampleTest() {
234      var ga = CreateGpSymbolicRegressionSample();
235      XmlGenerator.Serialize(ga, "../../SGP_SymbReg.hl");
236    }
237    [TestMethod]
238    public void RunGpSymbolicRegressionSampleTest() {
239      var ga = CreateGpSymbolicRegressionSample();
240      ga.SetSeedRandomly.Value = false;
241      RunAlgorithm(ga);
242      Assert.AreEqual(0.790111952286997, GetDoubleResult(ga, "BestQuality"), 1E-8);
243      Assert.AreEqual(0.547381191721895, GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
244      Assert.AreEqual(0, GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
245      Assert.AreEqual(50950, GetIntResult(ga, "EvaluatedSolutions"));
246    }
247
248    private GeneticAlgorithm CreateGpSymbolicRegressionSample() {
249      GeneticAlgorithm ga = new GeneticAlgorithm();
250      #region Problem Configuration
251      SymbolicRegressionSingleObjectiveProblem symbRegProblem = new SymbolicRegressionSingleObjectiveProblem();
252      symbRegProblem.Name = "Tower Symbolic Regression Problem";
253      symbRegProblem.Description = "Tower Dataset (downloaded from: http://vanillamodeling.com/realproblems.html)";
254      RegressionRealWorldInstanceProvider provider = new RegressionRealWorldInstanceProvider();
255      var instance = provider.GetDataDescriptors().Where(x => x.Name.Equals("TowerData")).Single();
256      var towerProblemData = (RegressionProblemData)provider.LoadData(instance);
257      towerProblemData.TargetVariableParameter.Value = towerProblemData.TargetVariableParameter.ValidValues
258        .First(v => v.Value == "towerResponse");
259      towerProblemData.InputVariables.SetItemCheckedState(
260        towerProblemData.InputVariables.Single(x => x.Value == "x1"), true);
261      towerProblemData.InputVariables.SetItemCheckedState(
262        towerProblemData.InputVariables.Single(x => x.Value == "x7"), false);
263      towerProblemData.InputVariables.SetItemCheckedState(
264        towerProblemData.InputVariables.Single(x => x.Value == "x11"), false);
265      towerProblemData.InputVariables.SetItemCheckedState(
266        towerProblemData.InputVariables.Single(x => x.Value == "x16"), false);
267      towerProblemData.InputVariables.SetItemCheckedState(
268        towerProblemData.InputVariables.Single(x => x.Value == "x21"), false);
269      towerProblemData.InputVariables.SetItemCheckedState(
270        towerProblemData.InputVariables.Single(x => x.Value == "x25"), false);
271      towerProblemData.InputVariables.SetItemCheckedState(
272        towerProblemData.InputVariables.Single(x => x.Value == "towerResponse"), false);
273      towerProblemData.TrainingPartition.Start = 0;
274      towerProblemData.TrainingPartition.End = 4000;
275      towerProblemData.TestPartition.Start = 4000;
276      towerProblemData.TestPartition.End = 4999;
277      towerProblemData.Name = "Data imported from towerData.txt";
278      towerProblemData.Description = "Chemical concentration at top of distillation tower, dataset downloaded from: http://vanillamodeling.com/realproblems.html, best R² achieved with nu-SVR = 0.97";
279      symbRegProblem.ProblemData = towerProblemData;
280
281      // configure grammar
282      var grammar = new TypeCoherentExpressionGrammar();
283      grammar.ConfigureAsDefaultRegressionGrammar();
284      grammar.Symbols.OfType<VariableCondition>().Single().InitialFrequency = 0.0;
285      var varSymbol = grammar.Symbols.OfType<Variable>().Where(x => !(x is LaggedVariable)).Single();
286      varSymbol.WeightMu = 1.0;
287      varSymbol.WeightSigma = 1.0;
288      varSymbol.WeightManipulatorMu = 0.0;
289      varSymbol.WeightManipulatorSigma = 0.05;
290      varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
291      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
292      constSymbol.MaxValue = 20;
293      constSymbol.MinValue = -20;
294      constSymbol.ManipulatorMu = 0.0;
295      constSymbol.ManipulatorSigma = 1;
296      constSymbol.MultiplicativeManipulatorSigma = 0.03;
297      symbRegProblem.SymbolicExpressionTreeGrammar = grammar;
298
299      // configure remaining problem parameters
300      symbRegProblem.BestKnownQuality.Value = 0.97;
301      symbRegProblem.FitnessCalculationPartition.Start = 0;
302      symbRegProblem.FitnessCalculationPartition.End = 2800;
303      symbRegProblem.ValidationPartition.Start = 2800;
304      symbRegProblem.ValidationPartition.End = 4000;
305      symbRegProblem.RelativeNumberOfEvaluatedSamples.Value = 1;
306      symbRegProblem.MaximumSymbolicExpressionTreeLength.Value = 150;
307      symbRegProblem.MaximumSymbolicExpressionTreeDepth.Value = 12;
308      symbRegProblem.MaximumFunctionDefinitions.Value = 0;
309      symbRegProblem.MaximumFunctionArguments.Value = 0;
310
311      symbRegProblem.EvaluatorParameter.Value = new SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator();
312      #endregion
313      #region Algorithm Configuration
314      ga.Problem = symbRegProblem;
315      ga.Name = "Genetic Programming - Symbolic Regression";
316      ga.Description = "A standard genetic programming algorithm to solve a symbolic regression problem (tower dataset)";
317      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeManipulator>(
318        ga, 1000, 1, 50, 0.15, 5);
319      var mutator = (MultiSymbolicExpressionTreeManipulator)ga.Mutator;
320      mutator.Operators.OfType<FullTreeShaker>().Single().ShakingFactor = 0.1;
321      mutator.Operators.OfType<OnePointShaker>().Single().ShakingFactor = 1.0;
322
323      ga.Analyzer.Operators.SetItemCheckedState(
324        ga.Analyzer.Operators
325        .OfType<SymbolicRegressionSingleObjectiveOverfittingAnalyzer>()
326        .Single(), false);
327      ga.Analyzer.Operators.SetItemCheckedState(
328        ga.Analyzer.Operators
329        .OfType<SymbolicDataAnalysisAlleleFrequencyAnalyzer>()
330        .First(), false);
331      #endregion
332      return ga;
333    }
334    #endregion
335    #region Symbolic Classification
336    [TestMethod]
337    public void CreateGpSymbolicClassificationSampleTest() {
338      var ga = CreateGpSymbolicClassificationSample();
339      XmlGenerator.Serialize(ga, "../../SGP_SymbClass.hl");
340    }
341
342    [TestMethod]
343    public void RunGpSymbolicClassificationSampleTest() {
344      var ga = CreateGpSymbolicClassificationSample();
345      ga.SetSeedRandomly.Value = false;
346      RunAlgorithm(ga);
347      Assert.AreEqual(0.14458636369766503, GetDoubleResult(ga, "BestQuality"), 1E-8);
348      Assert.AreEqual(2.5613992769560352, GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
349      Assert.AreEqual(100.62175156249987, GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
350      Assert.AreEqual(100900, GetIntResult(ga, "EvaluatedSolutions"));
351      var bestTrainingSolution = (IClassificationSolution)ga.Results["Best training solution"].Value;
352      Assert.AreEqual(0.80625, bestTrainingSolution.TrainingAccuracy, 1E-8);
353      Assert.AreEqual(0.782608695652174, bestTrainingSolution.TestAccuracy, 1E-8);
354    }
355
356    private GeneticAlgorithm CreateGpSymbolicClassificationSample() {
357      GeneticAlgorithm ga = new GeneticAlgorithm();
358      #region Problem Configuration
359      SymbolicClassificationSingleObjectiveProblem symbClassProblem = new SymbolicClassificationSingleObjectiveProblem();
360      symbClassProblem.Name = "Mammography Classification Problem";
361      symbClassProblem.Description = "Mammography dataset imported from the UCI machine learning repository (http://archive.ics.uci.edu/ml/datasets/Mammographic+Mass)";
362      UCIInstanceProvider provider = new UCIInstanceProvider();
363      var instance = provider.GetDataDescriptors().Where(x => x.Name.Equals("Mammography, M. Elter, 2007")).Single();
364      var mammoData = (ClassificationProblemData)provider.LoadData(instance);
365      mammoData.TargetVariableParameter.Value = mammoData.TargetVariableParameter.ValidValues
366        .First(v => v.Value == "Severity");
367      mammoData.InputVariables.SetItemCheckedState(
368        mammoData.InputVariables.Single(x => x.Value == "BI-RADS"), false);
369      mammoData.InputVariables.SetItemCheckedState(
370        mammoData.InputVariables.Single(x => x.Value == "Age"), true);
371      mammoData.InputVariables.SetItemCheckedState(
372        mammoData.InputVariables.Single(x => x.Value == "Shape"), true);
373      mammoData.InputVariables.SetItemCheckedState(
374        mammoData.InputVariables.Single(x => x.Value == "Margin"), true);
375      mammoData.InputVariables.SetItemCheckedState(
376        mammoData.InputVariables.Single(x => x.Value == "Density"), true);
377      mammoData.InputVariables.SetItemCheckedState(
378        mammoData.InputVariables.Single(x => x.Value == "Severity"), false);
379      mammoData.TrainingPartition.Start = 0;
380      mammoData.TrainingPartition.End = 800;
381      mammoData.TestPartition.Start = 800;
382      mammoData.TestPartition.End = 961;
383      mammoData.Name = "Data imported from mammographic_masses.csv";
384      mammoData.Description = "Original dataset: http://archive.ics.uci.edu/ml/datasets/Mammographic+Mass, missing values have been replaced with median values.";
385      symbClassProblem.ProblemData = mammoData;
386
387      // configure grammar
388      var grammar = new TypeCoherentExpressionGrammar();
389      grammar.ConfigureAsDefaultClassificationGrammar();
390      grammar.Symbols.OfType<VariableCondition>().Single().Enabled = false;
391      var varSymbol = grammar.Symbols.OfType<Variable>().Where(x => !(x is LaggedVariable)).Single();
392      varSymbol.WeightMu = 1.0;
393      varSymbol.WeightSigma = 1.0;
394      varSymbol.WeightManipulatorMu = 0.0;
395      varSymbol.WeightManipulatorSigma = 0.05;
396      varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
397      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
398      constSymbol.MaxValue = 20;
399      constSymbol.MinValue = -20;
400      constSymbol.ManipulatorMu = 0.0;
401      constSymbol.ManipulatorSigma = 1;
402      constSymbol.MultiplicativeManipulatorSigma = 0.03;
403      symbClassProblem.SymbolicExpressionTreeGrammar = grammar;
404
405      // configure remaining problem parameters
406      symbClassProblem.BestKnownQuality.Value = 0.0;
407      symbClassProblem.FitnessCalculationPartition.Start = 0;
408      symbClassProblem.FitnessCalculationPartition.End = 400;
409      symbClassProblem.ValidationPartition.Start = 400;
410      symbClassProblem.ValidationPartition.End = 800;
411      symbClassProblem.RelativeNumberOfEvaluatedSamples.Value = 1;
412      symbClassProblem.MaximumSymbolicExpressionTreeLength.Value = 100;
413      symbClassProblem.MaximumSymbolicExpressionTreeDepth.Value = 10;
414      symbClassProblem.MaximumFunctionDefinitions.Value = 0;
415      symbClassProblem.MaximumFunctionArguments.Value = 0;
416      symbClassProblem.EvaluatorParameter.Value = new SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator();
417      #endregion
418      #region Algorithm Configuration
419      ga.Problem = symbClassProblem;
420      ga.Name = "Genetic Programming - Symbolic Classification";
421      ga.Description = "A standard genetic programming algorithm to solve a classification problem (Mammographic+Mass dataset)";
422      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeManipulator>(
423        ga, 1000, 1, 100, 0.15, 5
424        );
425
426      var mutator = (MultiSymbolicExpressionTreeManipulator)ga.Mutator;
427      mutator.Operators.OfType<FullTreeShaker>().Single().ShakingFactor = 0.1;
428      mutator.Operators.OfType<OnePointShaker>().Single().ShakingFactor = 1.0;
429
430      ga.Analyzer.Operators.SetItemCheckedState(
431        ga.Analyzer.Operators
432        .OfType<SymbolicClassificationSingleObjectiveOverfittingAnalyzer>()
433        .Single(), false);
434      ga.Analyzer.Operators.SetItemCheckedState(
435        ga.Analyzer.Operators
436        .OfType<SymbolicDataAnalysisAlleleFrequencyAnalyzer>()
437        .First(), false);
438      #endregion
439      return ga;
440    }
441    #endregion
442    #region LawnMower
443    [TestMethod]
444    public void RunGpLawnMowerSampleTest() {
445      var ga = CreateGpLawnMowerSample();
446      ga.SetSeedRandomly.Value = false;
447      RunAlgorithm(ga);
448    }
449
450    public GeneticAlgorithm CreateGpLawnMowerSample() {
451      GeneticAlgorithm ga = new GeneticAlgorithm();
452      #region Problem Configuration
453      var problem = new HeuristicLab.Problems.LawnMower.Problem();
454      #endregion
455      #region Algorithm Configuration
456      ga.Name = "Genetic Programming - Lawn Mower";
457      ga.Description = "A standard genetic programming algorithm to solve the lawn mower problem";
458      ga.Problem = problem;
459      ConfigureGeneticAlgorithmParameters<TournamentSelector, SubtreeCrossover, MultiSymbolicExpressionTreeArchitectureManipulator>(
460        ga, 1000, 1, 50, 0.25, 5);
461      var mutator = (MultiSymbolicExpressionTreeArchitectureManipulator)ga.Mutator;
462      mutator.Operators.SetItemCheckedState(mutator.Operators
463        .OfType<OnePointShaker>()
464        .Single(), false);
465      #endregion
466      return ga;
467    }
468    #endregion
469    #endregion
470
471    #region ES
472    #region Griewank
473    [TestMethod]
474    public void CreateEsGriewankSampleTest() {
475      var es = CreateEsGriewankSample();
476      XmlGenerator.Serialize(es, "../../ES_Griewank.hl");
477    }
478    [TestMethod]
479    public void RunEsGriewankSampleTest() {
480      var es = CreateEsGriewankSample();
481      es.SetSeedRandomly.Value = false;
482      RunAlgorithm(es);
483      Assert.AreEqual(0, GetDoubleResult(es, "BestQuality"));
484      Assert.AreEqual(0, GetDoubleResult(es, "CurrentAverageQuality"));
485      Assert.AreEqual(0, GetDoubleResult(es, "CurrentWorstQuality"));
486      Assert.AreEqual(100020, GetIntResult(es, "EvaluatedSolutions"));
487    }
488
489    private EvolutionStrategy CreateEsGriewankSample() {
490      EvolutionStrategy es = new EvolutionStrategy();
491      #region Problem Configuration
492      SingleObjectiveTestFunctionProblem problem = new SingleObjectiveTestFunctionProblem();
493
494      problem.ProblemSize.Value = 10;
495      problem.EvaluatorParameter.Value = new GriewankEvaluator();
496      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
497      problem.Maximization.Value = false;
498      problem.Bounds = new DoubleMatrix(new double[,] { { -600, 600 } });
499      problem.BestKnownQuality.Value = 0;
500      problem.BestKnownSolutionParameter.Value = new RealVector(10);
501      problem.Name = "Single Objective Test Function";
502      problem.Description = "Test function with real valued inputs and a single objective.";
503      #endregion
504      #region Algorithm Configuration
505      es.Name = "Evolution Strategy - Griewank";
506      es.Description = "An evolution strategy which solves the 10-dimensional Griewank test function";
507      es.Problem = problem;
508      ConfigureEvolutionStrategyParameters<AverageCrossover, NormalAllPositionsManipulator,
509        StdDevStrategyVectorCreator, StdDevStrategyVectorCrossover, StdDevStrategyVectorManipulator>(
510        es, 20, 500, 2, 200, false);
511
512      StdDevStrategyVectorCreator strategyCreator = (StdDevStrategyVectorCreator)es.StrategyParameterCreator;
513      strategyCreator.BoundsParameter.Value = new DoubleMatrix(new double[,] { { 1, 20 } });
514
515      StdDevStrategyVectorManipulator strategyManipulator = (StdDevStrategyVectorManipulator)es.StrategyParameterManipulator;
516      strategyManipulator.BoundsParameter.Value = new DoubleMatrix(new double[,] { { 1E-12, 30 } });
517      strategyManipulator.GeneralLearningRateParameter.Value = new DoubleValue(0.22360679774997896);
518      strategyManipulator.LearningRateParameter.Value = new DoubleValue(0.39763536438352531);
519      #endregion
520      return es;
521    }
522    #endregion
523    #endregion
524
525    #region Island GA
526    #region TSP
527    [TestMethod]
528    public void CreateIslandGaTspSampleTest() {
529      var ga = CreateIslandGaTspSample();
530      XmlGenerator.Serialize(ga, "../../IslandGA_TSP.hl");
531    }
532    [TestMethod]
533    public void RunIslandGaTspSampleTest() {
534      var ga = CreateIslandGaTspSample();
535      ga.SetSeedRandomly.Value = false;
536      RunAlgorithm(ga);
537      Assert.AreEqual(9918, GetDoubleResult(ga, "BestQuality"));
538      Assert.AreEqual(10324.64, GetDoubleResult(ga, "CurrentAverageQuality"));
539      Assert.AreEqual(11823, GetDoubleResult(ga, "CurrentWorstQuality"));
540      Assert.AreEqual(495500, GetIntResult(ga, "EvaluatedSolutions"));
541    }
542
543    private IslandGeneticAlgorithm CreateIslandGaTspSample() {
544      IslandGeneticAlgorithm ga = new IslandGeneticAlgorithm();
545      #region Problem Configuration
546      var provider = new TSPLIBTSPInstanceProvider();
547      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
548      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
549      tspProblem.Load(provider.LoadData(instance));
550      tspProblem.UseDistanceMatrix.Value = true;
551      #endregion
552      #region Algorithm Configuration
553      ga.Name = "Island Genetic Algorithm - TSP";
554      ga.Description = "An island genetic algorithm which solves the \"ch130\" traveling salesman problem (imported from TSPLIB)";
555      ga.Problem = tspProblem;
556      ConfigureIslandGeneticAlgorithmParameters<ProportionalSelector, OrderCrossover2, InversionManipulator,
557        UnidirectionalRingMigrator, BestSelector, WorstReplacer>(
558        ga, 100, 1, 1000, 0.05, 5, 50, 0.25);
559      #endregion
560      return ga;
561    }
562    #endregion
563    #endregion
564
565    #region LS
566    #region Knapsack
567    [TestMethod]
568    public void CreateLocalSearchKnapsackSampleTest() {
569      var ls = CreateLocalSearchKnapsackSample();
570      XmlGenerator.Serialize(ls, "../../LS_Knapsack.hl");
571    }
572    [TestMethod]
573    public void RunLocalSearchKnapsackSampleTest() {
574      var ls = CreateLocalSearchKnapsackSample();
575      ls.SetSeedRandomly.Value = false;
576      RunAlgorithm(ls);
577      Assert.AreEqual(345, GetDoubleResult(ls, "BestQuality"));
578      Assert.AreEqual(340.70731707317071, GetDoubleResult(ls, "CurrentAverageQuality"));
579      Assert.AreEqual(337, GetDoubleResult(ls, "CurrentWorstQuality"));
580      Assert.AreEqual(82000, GetIntResult(ls, "EvaluatedMoves"));
581    }
582
583    private LocalSearch CreateLocalSearchKnapsackSample() {
584      LocalSearch ls = new LocalSearch();
585      #region Problem Configuration
586      KnapsackProblem problem = new KnapsackProblem();
587      problem.BestKnownQuality = new DoubleValue(362);
588      problem.BestKnownSolution = new HeuristicLab.Encodings.BinaryVectorEncoding.BinaryVector(new bool[] {
589       true , false, false, true , true , true , true , true , false, true , true , true , true , true , true , false, true , false, true , true , false, true , true , false, true , false, true , true , true , false, true , true , false, true , true , false, true , false, true , true , true , true , true , true , true , true , true , true , true , true , true , false, true , false, false, true , true , false, true , true , true , true , true , true , true , true , false, true , false, true , true , true , true , false, true , true , true , true , true , true , true , true});
590      problem.EvaluatorParameter.Value = new KnapsackEvaluator();
591      problem.SolutionCreatorParameter.Value = new RandomBinaryVectorCreator();
592      problem.KnapsackCapacity.Value = 297;
593      problem.Maximization.Value = true;
594      problem.Penalty.Value = 1;
595      problem.Values = new IntArray(new int[] {
596  6, 1, 1, 6, 7, 8, 7, 4, 2, 5, 2, 6, 7, 8, 7, 1, 7, 1, 9, 4, 2, 6, 5,  3, 5, 3, 3, 6, 5, 2, 4, 9, 4, 5, 7, 1, 4, 3, 5, 5, 8, 3, 6, 7, 3, 9, 7, 7, 5, 5, 7, 1, 4, 4, 3, 9, 5, 1, 6, 2, 2, 6, 1, 6, 5, 4, 4, 7, 1,  8, 9, 9, 7, 4, 3, 8, 7, 5, 7, 4, 4, 5});
597      problem.Weights = new IntArray(new int[] {
598 1, 9, 3, 6, 5, 3, 8, 1, 7, 4, 2, 1, 2, 7, 9, 9, 8, 4, 9, 2, 4, 8, 3, 7, 5, 7, 5, 5, 1, 9, 8, 7, 8, 9, 1, 3, 3, 8, 8, 5, 1, 2, 4, 3, 6, 9, 4, 4, 9, 7, 4, 5, 1, 9, 7, 6, 7, 4, 7, 1, 2, 1, 2, 9, 8, 6, 8, 4, 7, 6, 7, 5, 3, 9, 4, 7, 4, 6, 1, 2, 5, 4});
599      problem.Name = "Knapsack Problem";
600      problem.Description = "Represents a Knapsack problem.";
601      #endregion
602      #region Algorithm Configuration
603      ls.Name = "Local Search - Knapsack";
604      ls.Description = "A local search algorithm that solves a randomly generated Knapsack problem";
605      ls.Problem = problem;
606      ls.MaximumIterations.Value = 1000;
607      ls.MoveEvaluator = ls.MoveEvaluatorParameter.ValidValues
608        .OfType<KnapsackOneBitflipMoveEvaluator>()
609        .Single();
610      ls.MoveGenerator = ls.MoveGeneratorParameter.ValidValues
611        .OfType<ExhaustiveOneBitflipMoveGenerator>()
612        .Single();
613      ls.MoveMaker = ls.MoveMakerParameter.ValidValues
614        .OfType<OneBitflipMoveMaker>()
615        .Single();
616      ls.SampleSize.Value = 100;
617      ls.Seed.Value = 0;
618      ls.SetSeedRandomly.Value = true;
619      #endregion
620      ls.Engine = new ParallelEngine();
621      return ls;
622    }
623    #endregion
624    #endregion
625
626    #region PSO
627    #region Schwefel
628    [TestMethod]
629    public void CreatePsoSchwefelSampleTest() {
630      var pso = CreatePsoSchwefelSample();
631      XmlGenerator.Serialize(pso, "../../PSO_Schwefel.hl");
632    }
633    [TestMethod]
634    public void RunPsoSchwefelSampleTest() {
635      var pso = CreatePsoSchwefelSample();
636      pso.SetSeedRandomly.Value = false;
637      RunAlgorithm(pso);
638      if (!Environment.Is64BitProcess) {
639        Assert.AreEqual(118.44027985932837, GetDoubleResult(pso, "BestQuality"));
640        Assert.AreEqual(140.71570105946438, GetDoubleResult(pso, "CurrentAverageQuality"));
641        Assert.AreEqual(220.956806502853, GetDoubleResult(pso, "CurrentWorstQuality"));
642        Assert.AreEqual(1000, GetIntResult(pso, "Iterations"));
643      } else {
644        Assert.AreEqual(118.43958282879345, GetDoubleResult(pso, "BestQuality"));
645        Assert.AreEqual(139.43946864779372, GetDoubleResult(pso, "CurrentAverageQuality"));
646        Assert.AreEqual(217.14654589055152, GetDoubleResult(pso, "CurrentWorstQuality"));
647        Assert.AreEqual(1000, GetIntResult(pso, "Iterations"));
648      }
649    }
650    private ParticleSwarmOptimization CreatePsoSchwefelSample() {
651      ParticleSwarmOptimization pso = new ParticleSwarmOptimization();
652      #region Problem Configuration
653      var problem = new SingleObjectiveTestFunctionProblem();
654      problem.BestKnownQuality.Value = 0.0;
655      problem.BestKnownSolutionParameter.Value = new RealVector(new double[] { 420.968746, 420.968746 });
656      problem.Bounds = new DoubleMatrix(new double[,] { { -500, 500 } });
657      problem.EvaluatorParameter.Value = new SchwefelEvaluator();
658      problem.Maximization.Value = false;
659      problem.ProblemSize.Value = 2;
660      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
661      #endregion
662      #region Algorithm Configuration
663      pso.Name = "Particle Swarm Optimization - Schwefel";
664      pso.Description = "A particle swarm optimization algorithm which solves the 2-dimensional Schwefel test function (based on the description in Pedersen, M.E.H. (2010). PhD thesis. University of Southampton)";
665      pso.Problem = problem;
666      pso.Inertia.Value = 10;
667      pso.MaxIterations.Value = 1000;
668      pso.NeighborBestAttraction.Value = 0.5;
669      pso.PersonalBestAttraction.Value = -0.01;
670      pso.SwarmSize.Value = 50;
671
672      var inertiaUpdater = pso.InertiaUpdaterParameter.ValidValues
673        .OfType<ExponentialDiscreteDoubleValueModifier>()
674        .Single();
675      inertiaUpdater.StartValueParameter.Value = new DoubleValue(10);
676      inertiaUpdater.EndValueParameter.Value = new DoubleValue(1);
677      pso.InertiaUpdater = inertiaUpdater;
678
679      pso.ParticleCreator = pso.ParticleCreatorParameter.ValidValues
680        .OfType<RealVectorParticleCreator>()
681        .Single();
682      var swarmUpdater = pso.SwarmUpdaterParameter.ValidValues
683        .OfType<RealVectorSwarmUpdater>()
684        .Single();
685      swarmUpdater.VelocityBoundsIndexParameter.ActualName = "Iterations";
686      swarmUpdater.VelocityBoundsParameter.Value = new DoubleMatrix(new double[,] { { -10, 10 } });
687      swarmUpdater.VelocityBoundsStartValueParameter.Value = new DoubleValue(10.0);
688      swarmUpdater.VelocityBoundsEndValueParameter.Value = new DoubleValue(1.0);
689      swarmUpdater.VelocityBoundsScalingOperatorParameter.Value = swarmUpdater.VelocityBoundsScalingOperatorParameter.ValidValues
690        .OfType<ExponentialDiscreteDoubleValueModifier>()
691        .Single();
692
693      pso.TopologyInitializer = null;
694      pso.TopologyUpdater = null;
695      pso.SwarmUpdater = swarmUpdater;
696      pso.Seed.Value = 0;
697      pso.SetSeedRandomly.Value = true;
698      #endregion
699      pso.Engine = new ParallelEngine();
700      return pso;
701    }
702    #endregion
703    #endregion
704
705    #region SA
706    #region Rastrigin
707    [TestMethod]
708    public void CreateSimulatedAnnealingRastriginSampleTest() {
709      var sa = CreateSimulatedAnnealingRastriginSample();
710      XmlGenerator.Serialize(sa, "../../SA_Rastrigin.hl");
711    }
712    [TestMethod]
713    public void RunSimulatedAnnealingRastriginSampleTest() {
714      var sa = CreateSimulatedAnnealingRastriginSample();
715      sa.SetSeedRandomly.Value = false;
716      RunAlgorithm(sa);
717      Assert.AreEqual(0.00014039606034543795, GetDoubleResult(sa, "BestQuality"));
718      Assert.AreEqual(5000, GetIntResult(sa, "EvaluatedMoves"));
719    }
720    private SimulatedAnnealing CreateSimulatedAnnealingRastriginSample() {
721      SimulatedAnnealing sa = new SimulatedAnnealing();
722      #region Problem Configuration
723      var problem = new SingleObjectiveTestFunctionProblem();
724      problem.BestKnownQuality.Value = 0.0;
725      problem.BestKnownSolutionParameter.Value = new RealVector(new double[] { 0, 0 });
726      problem.Bounds = new DoubleMatrix(new double[,] { { -5.12, 5.12 } });
727      problem.EvaluatorParameter.Value = new RastriginEvaluator();
728      problem.Maximization.Value = false;
729      problem.ProblemSize.Value = 2;
730      problem.SolutionCreatorParameter.Value = new UniformRandomRealVectorCreator();
731      #endregion
732      #region Algorithm Configuration
733      sa.Name = "Simulated Annealing - Rastrigin";
734      sa.Description = "A simulated annealing algorithm that solves the 2-dimensional Rastrigin test function";
735      sa.Problem = problem;
736      var annealingOperator = sa.AnnealingOperatorParameter.ValidValues
737        .OfType<ExponentialDiscreteDoubleValueModifier>()
738        .Single();
739      annealingOperator.StartIndexParameter.Value = new IntValue(0);
740      sa.AnnealingOperator = annealingOperator;
741
742      sa.EndTemperature.Value = 1E-6;
743      sa.InnerIterations.Value = 50;
744      sa.MaximumIterations.Value = 100;
745      var moveEvaluator = sa.MoveEvaluatorParameter.ValidValues
746        .OfType<RastriginAdditiveMoveEvaluator>()
747        .Single();
748      moveEvaluator.A.Value = 10;
749      sa.MoveEvaluator = moveEvaluator;
750
751      var moveGenerator = sa.MoveGeneratorParameter.ValidValues
752        .OfType<StochasticNormalMultiMoveGenerator>()
753        .Single();
754      moveGenerator.SigmaParameter.Value = new DoubleValue(1);
755      sa.MoveGenerator = moveGenerator;
756
757      sa.MoveMaker = sa.MoveMakerParameter.ValidValues
758        .OfType<AdditiveMoveMaker>()
759        .Single();
760
761      sa.Seed.Value = 0;
762      sa.SetSeedRandomly.Value = true;
763      sa.StartTemperature.Value = 1;
764      #endregion
765      sa.Engine = new ParallelEngine();
766      return sa;
767    }
768    #endregion
769    #endregion
770
771    #region TS
772    #region TSP
773    [TestMethod]
774    public void CreateTabuSearchTspSampleTest() {
775      var ts = CreateTabuSearchTspSample();
776      XmlGenerator.Serialize(ts, "../../TS_TSP.hl");
777    }
778    [TestMethod]
779    public void RunTabuSearchTspSampleTest() {
780      var ts = CreateTabuSearchTspSample();
781      ts.SetSeedRandomly.Value = false;
782      RunAlgorithm(ts);
783      Assert.AreEqual(6441, GetDoubleResult(ts, "BestQuality"));
784      Assert.AreEqual(7401.666666666667, GetDoubleResult(ts, "CurrentAverageQuality"));
785      Assert.AreEqual(8418, GetDoubleResult(ts, "CurrentWorstQuality"));
786      Assert.AreEqual(750000, GetIntResult(ts, "EvaluatedMoves"));
787    }
788
789    private TabuSearch CreateTabuSearchTspSample() {
790      TabuSearch ts = new TabuSearch();
791      #region Problem Configuration
792      var provider = new TSPLIBTSPInstanceProvider();
793      var instance = provider.GetDataDescriptors().Where(x => x.Name == "ch130").Single();
794      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
795      tspProblem.Load(provider.LoadData(instance));
796      tspProblem.UseDistanceMatrix.Value = true;
797      #endregion
798      #region Algorithm Configuration
799      ts.Name = "Tabu Search - TSP";
800      ts.Description = "A tabu search algorithm that solves the \"ch130\" TSP (imported from TSPLIB)";
801      ts.Problem = tspProblem;
802
803      ts.MaximumIterations.Value = 1000;
804      // move generator has to be set first
805      var moveGenerator = ts.MoveGeneratorParameter.ValidValues
806        .OfType<StochasticInversionMultiMoveGenerator>()
807        .Single();
808      ts.MoveGenerator = moveGenerator;
809      var moveEvaluator = ts.MoveEvaluatorParameter.ValidValues
810        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
811        .Single();
812      ts.MoveEvaluator = moveEvaluator;
813      var moveMaker = ts.MoveMakerParameter.ValidValues
814        .OfType<InversionMoveMaker>()
815        .Single();
816      ts.MoveMaker = moveMaker;
817      ts.SampleSize.Value = 750;
818      ts.Seed.Value = 0;
819      ts.SetSeedRandomly.Value = true;
820
821      var tabuChecker = ts.TabuCheckerParameter.ValidValues
822        .OfType<InversionMoveSoftTabuCriterion>()
823        .Single();
824      tabuChecker.UseAspirationCriterion.Value = true;
825      ts.TabuChecker = tabuChecker;
826
827      var tabuMaker = ts.TabuMakerParameter.ValidValues
828        .OfType<InversionMoveTabuMaker>()
829        .Single();
830      ts.TabuMaker = tabuMaker;
831      ts.TabuTenure.Value = 60;
832
833      #endregion
834      ts.Engine = new ParallelEngine();
835      return ts;
836    }
837    #endregion
838    #endregion
839
840    #region VNS
841    #region TSP
842    [TestMethod]
843    public void CreateVnsTspSampleTest() {
844      var vns = CreateVnsTspSample();
845      XmlGenerator.Serialize(vns, "../../VNS_TSP.hl");
846    }
847    [TestMethod]
848    public void RunVnsTspSampleTest() {
849      var vns = CreateVnsTspSample();
850      vns.SetSeedRandomly = false;
851      RunAlgorithm(vns);
852      Assert.AreEqual(867, GetDoubleResult(vns, "BestQuality"));
853      Assert.AreEqual(867, GetDoubleResult(vns, "CurrentAverageQuality"));
854      Assert.AreEqual(867, GetDoubleResult(vns, "CurrentWorstQuality"));
855      Assert.AreEqual(12975173, GetIntResult(vns, "EvaluatedSolutions"));
856    }
857
858    private VariableNeighborhoodSearch CreateVnsTspSample() {
859      VariableNeighborhoodSearch vns = new VariableNeighborhoodSearch();
860      #region Problem Configuration
861      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
862      tspProblem.BestKnownSolution = new Permutation(PermutationTypes.Absolute, new int[] {
863117, 65, 73, 74, 75, 76, 82, 86, 87, 94, 100, 106, 115, 120, 124, 107, 101, 108, 109, 102, 97, 90, 96, 95, 88, 89, 84, 78, 69, 57, 68, 56, 44, 55, 45, 36, 46, 37, 38, 47, 48, 59, 49, 58, 70, 77, 83, 79, 50, 80, 85, 98, 103, 110, 116, 121, 125, 133, 132, 138, 139, 146, 147, 159, 168, 169, 175, 182, 188, 201, 213, 189, 214, 221, 230, 246, 262, 276, 284, 275, 274, 261, 245, 229, 220, 228, 243, 259, 273, 282, 272, 258, 242, 257, 293, 292, 302, 310, 319, 320, 327, 326, 333, 340, 346, 339, 345, 344, 337, 338, 332, 325, 318, 309, 301, 291, 271, 251, 270, 233, 250, 269, 268, 280, 290, 300, 415, 440, 416, 417, 441, 458, 479, 418, 419, 395, 420, 442, 421, 396, 397, 422, 423, 461, 481, 502, 460, 501, 459, 480, 500, 517, 531, 516, 530, 499, 478, 457, 439, 414, 413, 412, 438, 456, 477, 498, 515, 529, 538, 547, 558, 559, 560, 548, 539, 549, 561, 562, 551, 550, 532, 540, 533, 541, 518, 534, 542, 552, 553, 554, 555, 535, 543, 556, 544, 536, 522, 505, 521, 520, 504, 519, 503, 482, 462, 463, 464, 483, 443, 465, 484, 506, 485, 507, 508, 487, 467, 486, 466, 445, 428, 444, 424, 425, 426, 427, 398, 399, 400, 381, 382, 371, 372, 401, 429, 446, 430, 402, 383, 366, 356, 357, 352, 385, 384, 403, 431, 447, 469, 468, 488, 489, 490, 470, 471, 448, 432, 433, 404, 405, 386, 373, 374, 367, 376, 375, 387, 491, 509, 537, 510, 492, 472, 449, 388, 389, 406, 450, 407, 377, 368, 359, 354, 350, 335, 324, 330, 390, 434, 451, 473, 493, 511, 523, 545, 563, 565, 567, 570, 569, 578, 577, 576, 575, 574, 573, 572, 580, 584, 583, 582, 587, 586, 585, 581, 579, 571, 568, 566, 564, 557, 546, 527, 513, 526, 525, 524, 512, 495, 494, 474, 452, 436, 409, 435, 453, 475, 496, 514, 528, 497, 455, 476, 454, 437, 411, 410, 394, 393, 392, 380, 370, 379, 408, 391, 378, 369, 364, 365, 361, 355, 351, 343, 336, 331, 317, 299, 286, 287, 278, 263, 264, 265, 223, 202, 248, 266, 279, 288, 289, 281, 267, 249, 232, 224, 216, 215, 204, 192, 193, 194, 186, 179, 185, 203, 191, 190, 177, 171, 161, 128, 135, 140, 149, 162, 150, 163, 172, 178, 173, 164, 152, 151, 141, 153, 165, 154, 142, 155, 143, 137, 136, 130, 129, 118, 114, 113, 105, 119, 123, 131, 144, 156, 157, 145, 158, 166, 167, 174, 180, 181, 187, 195, 205, 217, 226, 236, 225, 234, 252, 235, 253, 254, 255, 238, 239, 240, 241, 256, 237, 206, 207, 208, 196, 197, 198, 209, 199, 200, 211, 212, 219, 210, 218, 227, 244, 260, 283, 294, 295, 303, 296, 311, 304, 297, 298, 305, 285, 306, 314, 329, 321, 313, 312, 328, 334, 341, 347, 348, 353, 358, 362, 363, 360, 349, 342, 322, 323, 315, 316, 308, 307, 277, 247, 231, 222, 184, 183, 176, 170, 160, 148, 134, 127, 126, 111, 104, 92, 91, 71, 60, 51, 52, 40, 32, 23, 21, 20, 18, 17, 16, 14, 13, 11, 10, 7, 6, 5, 2, 1, 0, 3, 4, 31, 39, 25, 30, 35, 34, 33, 43, 54, 42, 27, 28, 29, 9, 8, 12, 15, 19, 22, 24, 26, 41, 67, 66, 64, 63, 53, 62, 61, 72, 81, 93, 99, 112, 122,
864      });
865      tspProblem.Coordinates = new DoubleMatrix(new double[,] {
866{48, 71}, {49, 71}, {50, 71}, {44, 70}, {45, 70}, {52, 70}, {53, 70}, {54, 70}, {41, 69}, {42, 69}, {55, 69}, {56, 69}, {40, 68}, {56, 68}, {57, 68}, {39, 67}, {57, 67}, {58, 67}, {59, 67}, {38, 66}, {59, 66}, {60, 66}, {37, 65}, {60, 65}, {36, 64}, {43, 64}, {35, 63}, {37, 63}, {41, 63}, {42, 63}, {43, 63}, {47, 63}, {61, 63}, {40, 62}, {41, 62}, {42, 62}, {43, 62}, {45, 62}, {46, 62}, {47, 62}, {62, 62}, {34, 61}, {38, 61}, {39, 61}, {42, 61}, {43, 61}, {44, 61}, {45, 61}, {46, 61}, {47, 61}, {52, 61}, {62, 61}, {63, 61}, {26, 60}, {38, 60}, {42, 60}, {43, 60}, {44, 60}, {46, 60}, {47, 60}, {63, 60}, {23, 59}, {24, 59}, {27, 59}, {29, 59}, {30, 59}, {31, 59}, {33, 59}, {42, 59}, {46, 59}, {47, 59}, {63, 59}, {21, 58}, {32, 58}, {33, 58}, {34, 58}, {35, 58}, {46, 58}, {47, 58}, {48, 58}, {53, 58}, {21, 57}, {35, 57}, {47, 57}, {48, 57}, {53, 57}, {36, 56}, {37, 56}, {46, 56}, {47, 56}, {48, 56}, {64, 56}, {65, 56}, {20, 55}, {38, 55}, {46, 55}, {47, 55}, {48, 55}, {52, 55}, {21, 54}, {40, 54}, {47, 54}, {48, 54}, {52, 54}, {65, 54}, {30, 53}, {41, 53}, {46, 53}, {47, 53}, {48, 53}, {52, 53}, {65, 53}, {21, 52}, {32, 52}, {33, 52}, {42, 52}, {51, 52}, {21, 51}, {33, 51}, {34, 51}, {43, 51}, {51, 51}, {21, 50}, {35, 50}, {44, 50}, {50, 50}, {66, 50}, {67, 50}, {21, 49}, {34, 49}, {36, 49}, {37, 49}, {46, 49}, {49, 49}, {67, 49}, {22, 48}, {36, 48}, {37, 48}, {46, 48}, {47, 48}, {22, 47}, {30, 47}, {34, 47}, {37, 47}, {38, 47}, {39, 47}, {47, 47}, {48, 47}, {67, 47}, {23, 46}, {28, 46}, {29, 46}, {30, 46}, {31, 46}, {32, 46}, {35, 46}, {37, 46}, {38, 46}, {39, 46}, {49, 46}, {67, 46}, {23, 45}, {28, 45}, {29, 45}, {31, 45}, {32, 45}, {40, 45}, {41, 45}, {49, 45}, {50, 45}, {68, 45}, {24, 44}, {29, 44}, {32, 44}, {41, 44}, {51, 44}, {68, 44}, {25, 43}, {30, 43}, {32, 43}, {42, 43}, {43, 43}, {51, 43}, {68, 43}, {69, 43}, {31, 42}, {32, 42}, {43, 42}, {52, 42}, {55, 42}, {26, 41}, {27, 41}, {31, 41}, {32, 41}, {33, 41}, {44, 41}, {45, 41}, {46, 41}, {47, 41}, {48, 41}, {49, 41}, {53, 41}, {25, 40}, {27, 40}, {32, 40}, {43, 40}, {44, 40}, {45, 40}, {46, 40}, {48, 40}, {49, 40}, {50, 40}, {51, 40}, {53, 40}, {56, 40}, {32, 39}, {33, 39}, {43, 39}, {50, 39}, {51, 39}, {54, 39}, {56, 39}, {69, 39}, {24, 38}, {32, 38}, {41, 38}, {42, 38}, {51, 38}, {52, 38}, {54, 38}, {57, 38}, {69, 38}, {31, 37}, {32, 37}, {40, 37}, {41, 37}, {42, 37}, {43, 37}, {44, 37}, {45, 37}, {46, 37}, {47, 37}, {48, 37}, {51, 37}, {52, 37}, {55, 37}, {57, 37}, {69, 37}, {24, 36}, {31, 36}, {32, 36}, {39, 36}, {40, 36}, {41, 36}, {42, 36}, {43, 36}, {45, 36}, {48, 36}, {49, 36}, {51, 36}, {53, 36}, {55, 36}, {58, 36}, {22, 35}, {23, 35}, {24, 35}, {25, 35}, {30, 35}, {31, 35}, {32, 35}, {39, 35}, {41, 35}, {49, 35}, {51, 35}, {55, 35}, {56, 35}, {58, 35}, {71, 35}, {20, 34}, {27, 34}, {30, 34}, {31, 34}, {51, 34}, {53, 34}, {57, 34}, {60, 34}, {18, 33}, {19, 33}, {29, 33}, {30, 33}, {31, 33}, {45, 33}, {46, 33}, {47, 33}, {52, 33}, {53, 33}, {55, 33}, {57, 33}, {58, 33}, {17, 32}, {30, 32}, {44, 32}, {47, 32}, {54, 32}, {57, 32}, {59, 32}, {61, 32}, {71, 32}, {72, 32}, {43, 31}, {47, 31}, {56, 31}, {58, 31}, {59, 31}, {61, 31}, {72, 31}, {74, 31}, {16, 30}, {43, 30}, {46, 30}, {47, 30}, {59, 30}, {63, 30}, {71, 30}, {75, 30}, {43, 29}, {46, 29}, {47, 29}, {59, 29}, {60, 29}, {75, 29}, {15, 28}, {43, 28}, {46, 28}, {61, 28}, {76, 28}, {15, 27}, {43, 27}, {44, 27}, {45, 27}, {46, 27}, {60, 27}, {62, 27}, {15, 26}, {43, 26}, {44, 26}, {46, 26}, {59, 26}, {60, 26}, {64, 26}, {77, 26}, {15, 25}, {58, 25}, {61, 25}, {77, 25}, {15, 24}, {53, 24}, {55, 24}, {61, 24}, {77, 24}, {62, 23}, {16, 22}, {61, 22}, {62, 22}, {15, 21}, {16, 21}, {52, 21}, {63, 21}, {77, 21}, {16, 20}, {17, 20}, {46, 20}, {47, 20}, {60, 20}, {62, 20}, {63, 20}, {65, 20}, {76, 20}, {15, 19}, {17, 19}, {18, 19}, {44, 19}, {45, 19}, {48, 19}, {53, 19}, {56, 19}, {60, 19}, {62, 19}, {67, 19}, {68, 19}, {76, 19}, {15, 18}, {18, 18}, {19, 18}, {20, 18}, {32, 18}, {33, 18}, {34, 18}, {41, 18}, {42, 18}, {43, 18}, {46, 18}, {48, 18}, {53, 18}, {59, 18}, {60, 18}, {69, 18}, {75, 18}, {16, 17}, {17, 17}, {20, 17}, {21, 17}, {22, 17}, {23, 17}, {24, 17}, {26, 17}, {28, 17}, {29, 17}, {30, 17}, {31, 17}, {32, 17}, {34, 17}, {35, 17}, {36, 17}, {37, 17}, {38, 17}, {39, 17}, {40, 17}, {44, 17}, {46, 17}, {48, 17}, {53, 17}, {56, 17}, {58, 17}, {75, 17}, {17, 16}, {18, 16}, {20, 16}, {24, 16}, {26, 16}, {27, 16}, {29, 16}, {33, 16}, {41, 16}, {42, 16}, {44, 16}, {47, 16}, {52, 16}, {57, 16}, {70, 16}, {73, 16}, {74, 16}, {17, 15}, {18, 15}, {20, 15}, {22, 15}, {24, 15}, {27, 15}, {29, 15}, {31, 15}, {33, 15}, {35, 15}, {36, 15}, {38, 15}, {39, 15}, {42, 15}, {45, 15}, {47, 15}, {52, 15}, {53, 15}, {55, 15}, {56, 15}, {70, 15}, {73, 15}, {17, 14}, {19, 14}, {21, 14}, {24, 14}, {26, 14}, {29, 14}, {31, 14}, {34, 14}, {37, 14}, {40, 14}, {42, 14}, {44, 14}, {46, 14}, {47, 14}, {53, 14}, {54, 14}, {55, 14}, {62, 14}, {70, 14}, {72, 14}, {17, 13}, {19, 13}, {21, 13}, {23, 13}, {25, 13}, {27, 13}, {30, 13}, {32, 13}, {34, 13}, {36, 13}, {38, 13}, {41, 13}, {43, 13}, {44, 13}, {45, 13}, {60, 13}, {70, 13}, {71, 13}, {18, 12}, {21, 12}, {23, 12}, {26, 12}, {28, 12}, {31, 12}, {34, 12}, {37, 12}, {39, 12}, {41, 12}, {42, 12}, {70, 12}, {18, 11}, {19, 11}, {20, 11}, {21, 11}, {24, 11}, {25, 11}, {27, 11}, {29, 11}, {31, 11}, {33, 11}, {35, 11}, {38, 11}, {41, 11}, {59, 11}, {26, 10}, {29, 10}, {32, 10}, {34, 10}, {36, 10}, {39, 10}, {40, 10}, {69, 10}, {21, 9}, {26, 9}, {28, 9}, {30, 9}, {32, 9}, {33, 9}, {35, 9}, {36, 9}, {37, 9}, {38, 9}, {39, 9}, {22, 8}, {27, 8}, {28, 8}, {29, 8}, {30, 8}, {31, 8}, {68, 8}, {23, 7}, {66, 7}, {24, 6}, {65, 6}, {25, 5}, {62, 5}, {63, 5}, {26, 4}, {55, 4}, {56, 4}, {57, 4}, {58, 4}, {59, 4}, {60, 4}, {61, 4}, {28, 3}, {53, 3}, {29, 2}, {50, 2}, {51, 2}, {52, 2}, {31, 1}, {32, 1}, {48, 1}
867      });
868      tspProblem.BestKnownQuality = new DoubleValue(867);
869
870      tspProblem.EvaluatorParameter.Value = new TSPRoundedEuclideanPathEvaluator();
871      tspProblem.SolutionCreatorParameter.Value = new RandomPermutationCreator();
872      tspProblem.UseDistanceMatrix.Value = true;
873      tspProblem.Name = "Funny TSP";
874      tspProblem.Description = "Represents a symmetric Traveling Salesman Problem.";
875      #endregion
876      #region Algorithm Configuration
877      vns.Name = "Variable Neighborhood Search - TSP";
878      vns.Description = "A variable neighborhood search algorithm which solves a funny TSP instance";
879      vns.Problem = tspProblem;
880
881      var localImprovement = vns.LocalImprovementParameter.ValidValues
882        .OfType<LocalSearchImprovementOperator>()
883        .Single();
884      // move generator has to be set first
885      localImprovement.MoveGenerator = localImprovement.MoveGeneratorParameter.ValidValues
886        .OfType<StochasticInversionMultiMoveGenerator>()
887        .Single();
888      localImprovement.MoveEvaluator = localImprovement.MoveEvaluatorParameter.ValidValues
889        .OfType<TSPInversionMoveRoundedEuclideanPathEvaluator>()
890        .Single();
891      localImprovement.MoveMaker = localImprovement.MoveMakerParameter.ValidValues
892        .OfType<InversionMoveMaker>()
893        .Single();
894      localImprovement.SampleSizeParameter.Value = new IntValue(500);
895      vns.LocalImprovement = localImprovement;
896
897      vns.LocalImprovementMaximumIterations = 150;
898      vns.MaximumIterations = 25;
899      vns.Seed = 0;
900      vns.SetSeedRandomly = true;
901      var shakingOperator = vns.ShakingOperatorParameter.ValidValues
902        .OfType<PermutationShakingOperator>()
903        .Single();
904      shakingOperator.Operators.SetItemCheckedState(shakingOperator.Operators
905        .OfType<Swap2Manipulator>()
906        .Single(), false);
907      shakingOperator.Operators.SetItemCheckedState(shakingOperator.Operators
908        .OfType<Swap3Manipulator>()
909        .Single(), false);
910      vns.ShakingOperator = shakingOperator;
911      #endregion
912      vns.Engine = new ParallelEngine();
913      return vns;
914    }
915    #endregion
916    #endregion
917
918
919    #region Gaussian Process Regression
920    [TestMethod]
921    public void CreateGaussianProcessRegressionSampleTest() {
922      var vns = CreateGaussianProcessRegressionSample();
923      XmlGenerator.Serialize(vns, "../../GaussianProcessRegression.hl");
924    }
925    [TestMethod]
926    public void RunGaussianProcessRegressionSample() {
927      var gpr = CreateGaussianProcessRegressionSample();
928      gpr.SetSeedRandomly = false;
929      gpr.Seed = 1618551877;
930      RunAlgorithm(gpr);
931      Assert.AreEqual(-940.48768748097029, GetDoubleResult(gpr, "NegativeLogLikelihood"));
932      Assert.AreEqual(0.99561947047986976, GetDoubleResult(gpr, "Training R²"));
933    }
934
935    private GaussianProcessRegression CreateGaussianProcessRegressionSample() {
936      var gpr = new GaussianProcessRegression();
937      var provider = new VariousInstanceProvider();
938      var instance = provider.GetDataDescriptors().Where(x => x.Name.Contains("Spatial co-evolution")).Single();
939      var regProblem = new RegressionProblem();
940      regProblem.Load(provider.LoadData(instance));
941      #region Algorithm Configuration
942      gpr.Name = "Gaussian Process Regression";
943      gpr.Description = "A Gaussian process regression algorithm applied to the spatial co-evolution benchmark problem.";
944      gpr.Problem = regProblem;
945
946      gpr.CovarianceFunction = new CovarianceSquaredExponentialIso();
947      gpr.MeanFunction = new MeanConst();
948      gpr.MinimizationIterations = 20;
949      gpr.Seed = 0;
950      gpr.SetSeedRandomly = true;
951      #endregion
952      gpr.Engine = new ParallelEngine();
953      return gpr;
954    }
955    #endregion
956
957    #region Scatter Search
958    #region VRP
959    [TestMethod]
960    public void CreateScatterSearchVRPSampleTest() {
961      var ss = CreateScatterSearchVRPSample();
962      XmlGenerator.Serialize(ss, "../../SS_VRP.hl");
963    }
964
965    [TestMethod]
966    public void RunScatterSearchVRPSampleTest() {
967      var ss = CreateScatterSearchVRPSample();
968      ss.SetSeedRandomly.Value = false;
969      RunAlgorithm(ss);
970      Assert.AreEqual(828.93686694283383, GetDoubleResult(ss, "BestQuality"));
971      Assert.AreEqual(868.63623986983077, GetDoubleResult(ss, "CurrentAverageQuality"));
972      Assert.AreEqual(1048.8333559209832, GetDoubleResult(ss, "CurrentWorstQuality"));
973      Assert.AreEqual(262622, GetIntResult(ss, "EvaluatedSolutions"));
974    }
975
976    private ScatterSearch CreateScatterSearchVRPSample() {
977      #region Problem Configuration
978      var provider = new SolomonInstanceProvider();
979      var instance = provider.GetDataDescriptors().Single(x => x.Name == "C101");
980      VehicleRoutingProblem vrpProblem = new VehicleRoutingProblem();
981      vrpProblem.Load(provider.LoadData(instance));
982      #endregion
983
984      #region Algorithm Configuration
985      ScatterSearch ss = new ScatterSearch();
986      ss.Engine = new SequentialEngine();
987      ss.Name = "Scatter Search - VRP";
988      ss.Description = "A scatter search algorithm which solves the \"C101\" vehicle routing problem (imported from Solomon)";
989      ss.Problem = vrpProblem;
990
991      var improver = ss.Problem.Operators.OfType<VRPIntraRouteImprovementOperator>().First();
992      improver.ImprovementAttemptsParameter.Value.Value = 15;
993      improver.SampleSizeParameter.Value.Value = 10;
994      ss.Improver = improver;
995
996      var pathRelinker = ss.Problem.Operators.OfType<VRPPathRelinker>().First();
997      pathRelinker.IterationsParameter.Value.Value = 25;
998      ss.PathRelinker = pathRelinker;
999
1000      var similarityCalculator = ss.SimilarityCalculatorParameter.ValidValues.OfType<VRPSimilarityCalculator>().First();
1001      ss.SimilarityCalculator = similarityCalculator;
1002
1003      ss.MaximumIterations.Value = 2;
1004      ss.PopulationSize.Value = 20;
1005      ss.ReferenceSetSize.Value = 10;
1006      ss.Seed.Value = 0;
1007      return ss;
1008      #endregion
1009    }
1010    #endregion
1011    #endregion
1012
1013    #region RAPGA
1014    #region Scheduling
1015    [TestMethod]
1016    public void CreateRAPGASchedulingSampleTest() {
1017      var ss = CreateRAPGASchedulingSample();
1018      XmlGenerator.Serialize(ss, "../../RAPGA_JSSP.hl");
1019    }
1020
1021    [TestMethod]
1022    public void RunRAPGASchedulingSampleTest() {
1023      var rapga = CreateRAPGASchedulingSample();
1024      rapga.SetSeedRandomly.Value = false;
1025      RunAlgorithm(rapga);
1026      Assert.AreEqual(982.00, GetDoubleResult(rapga, "BestQuality"));
1027      Assert.AreEqual(982.00, GetDoubleResult(rapga, "CurrentAverageQuality"));
1028      Assert.AreEqual(982.00, GetDoubleResult(rapga, "CurrentWorstQuality"));
1029      Assert.AreEqual(27100, GetIntResult(rapga, "EvaluatedSolutions"));
1030    }
1031
1032    private RAPGA CreateRAPGASchedulingSample() {
1033      #region Problem Configuration
1034      JobShopSchedulingProblem problem = new JobShopSchedulingProblem();
1035      #endregion
1036
1037      #region Algorithm Configuration
1038      RAPGA rapga = new RAPGA();
1039      rapga.Engine = new SequentialEngine();
1040      rapga.Name = "RAPGA - Job Shop Scheduling";
1041      rapga.Description = "A relevant alleles preserving genetic algorithm which solves a job shop scheduling problem";
1042      rapga.Problem = problem;
1043      rapga.Mutator = rapga.MutatorParameter.ValidValues.OfType<JSMSwapManipulator>().First();
1044      rapga.Seed.Value = 0;
1045      return rapga;
1046      #endregion
1047    }
1048    #endregion
1049    #endregion
1050
1051    #region Helpers
1052    private void ConfigureEvolutionStrategyParameters<R, M, SC, SR, SM>(EvolutionStrategy es, int popSize, int children, int parentsPerChild, int maxGens, bool plusSelection)
1053      where R : ICrossover
1054      where M : IManipulator
1055      where SC : IStrategyParameterCreator
1056      where SR : IStrategyParameterCrossover
1057      where SM : IStrategyParameterManipulator {
1058      es.PopulationSize.Value = popSize;
1059      es.Children.Value = children;
1060      es.ParentsPerChild.Value = parentsPerChild;
1061      es.MaximumGenerations.Value = maxGens;
1062      es.PlusSelection.Value = false;
1063
1064      es.Seed.Value = 0;
1065      es.SetSeedRandomly.Value = true;
1066
1067      es.Recombinator = es.RecombinatorParameter.ValidValues
1068        .OfType<R>()
1069        .Single();
1070
1071      es.Mutator = es.MutatorParameter.ValidValues
1072        .OfType<M>()
1073        .Single();
1074
1075      es.StrategyParameterCreator = es.StrategyParameterCreatorParameter.ValidValues
1076        .OfType<SC>()
1077        .Single();
1078      es.StrategyParameterCrossover = es.StrategyParameterCrossoverParameter.ValidValues
1079        .OfType<SR>()
1080        .Single();
1081      es.StrategyParameterManipulator = es.StrategyParameterManipulatorParameter.ValidValues
1082        .OfType<SM>()
1083        .Single();
1084      es.Engine = new ParallelEngine();
1085    }
1086
1087    private void ConfigureGeneticAlgorithmParameters<S, C, M>(GeneticAlgorithm ga, int popSize, int elites, int maxGens, double mutationRate, int tournGroupSize = 0)
1088      where S : ISelector
1089      where C : ICrossover
1090      where M : IManipulator {
1091      ga.Elites.Value = elites;
1092      ga.MaximumGenerations.Value = maxGens;
1093      ga.MutationProbability.Value = mutationRate;
1094      ga.PopulationSize.Value = popSize;
1095      ga.Seed.Value = 0;
1096      ga.SetSeedRandomly.Value = true;
1097      ga.Selector = ga.SelectorParameter.ValidValues
1098        .OfType<S>()
1099        .First();
1100
1101      ga.Crossover = ga.CrossoverParameter.ValidValues
1102        .OfType<C>()
1103        .First();
1104
1105      ga.Mutator = ga.MutatorParameter.ValidValues
1106        .OfType<M>()
1107        .First();
1108
1109      var tSelector = ga.Selector as TournamentSelector;
1110      if (tSelector != null) {
1111        tSelector.GroupSizeParameter.Value.Value = tournGroupSize;
1112      }
1113      ga.Engine = new ParallelEngine();
1114    }
1115
1116    private void ConfigureIslandGeneticAlgorithmParameters<S, C, M, Mi, MiS, MiR>(IslandGeneticAlgorithm ga, int popSize, int elites, int maxGens, double mutationRate, int numberOfIslands, int migrationInterval, double migrationRate)
1117      where S : ISelector
1118      where C : ICrossover
1119      where M : IManipulator
1120      where Mi : IMigrator
1121      where MiS : ISelector
1122      where MiR : IReplacer {
1123      ga.Elites.Value = elites;
1124      ga.MaximumGenerations.Value = maxGens;
1125      ga.MutationProbability.Value = mutationRate;
1126      ga.PopulationSize.Value = popSize;
1127      ga.NumberOfIslands.Value = numberOfIslands;
1128      ga.MigrationInterval.Value = migrationInterval;
1129      ga.MigrationRate.Value = migrationRate;
1130      ga.Seed.Value = 0;
1131      ga.SetSeedRandomly.Value = true;
1132      ga.Selector = ga.SelectorParameter.ValidValues
1133        .OfType<S>()
1134        .Single();
1135
1136      ga.Crossover = ga.CrossoverParameter.ValidValues
1137        .OfType<C>()
1138        .Single();
1139
1140      ga.Mutator = ga.MutatorParameter.ValidValues
1141        .OfType<M>()
1142        .Single();
1143      ga.Migrator = ga.MigratorParameter.ValidValues
1144        .OfType<Mi>()
1145        .Single();
1146      ga.EmigrantsSelector = ga.EmigrantsSelectorParameter.ValidValues
1147        .OfType<MiS>()
1148        .Single();
1149      ga.ImmigrationReplacer = ga.ImmigrationReplacerParameter.ValidValues
1150        .OfType<MiR>()
1151        .Single();
1152      ga.Engine = new ParallelEngine();
1153    }
1154
1155
1156    private void RunAlgorithm(IAlgorithm a) {
1157      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
1158      Exception ex = null;
1159      a.Stopped += (src, e) => { trigger.Set(); };
1160      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
1161      a.Prepare();
1162      a.Start();
1163      trigger.WaitOne();
1164
1165      Assert.AreEqual(ex, null);
1166    }
1167
1168    private double GetDoubleResult(IAlgorithm a, string resultName) {
1169      return ((DoubleValue)a.Results[resultName].Value).Value;
1170    }
1171    private int GetIntResult(IAlgorithm a, string resultName) {
1172      return ((IntValue)a.Results[resultName].Value).Value;
1173    }
1174    #endregion
1175  }
1176}
Note: See TracBrowser for help on using the repository browser.