Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 9463 was 9463, checked in by swagner, 11 years ago

Adapted GPR sample test (#1890)

File size: 60.6 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2013 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.858344291534625, GetDoubleResult(ga, "BestQuality"), 1E-8);
243      Assert.AreEqual(0.56758466520692641, 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://www.symbolicregression.com/?q=towerProblem)";
254      RegressionRealWorldInstanceProvider provider = new RegressionRealWorldInstanceProvider();
255      var instance = provider.GetDataDescriptors().Where(x => x.Name.Equals("Tower")).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 = 3136;
275      towerProblemData.TestPartition.Start = 3136;
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 = 2300;
303      symbRegProblem.ValidationPartition.Start = 2300;
304      symbRegProblem.ValidationPartition.End = 3136;
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    #region Gaussian Process Regression
919    [TestMethod]
920    public void CreateGaussianProcessRegressionSampleTest() {
921      var gpr = CreateGaussianProcessRegressionSample();
922      XmlGenerator.Serialize(gpr, "../../GPR.hl");
923    }
924    [TestMethod]
925    public void RunGaussianProcessRegressionSample() {
926      var gpr = CreateGaussianProcessRegressionSample();
927      gpr.SetSeedRandomly = false;
928      gpr.Seed = 1618551877;
929      RunAlgorithm(gpr);
930      Assert.AreEqual(-940.48768748097029, GetDoubleResult(gpr, "NegativeLogLikelihood"));
931      Assert.AreEqual(0.99561947047986976, GetDoubleResult(gpr, "Training R²"));
932    }
933
934    private GaussianProcessRegression CreateGaussianProcessRegressionSample() {
935      var gpr = new GaussianProcessRegression();
936      var provider = new VariousInstanceProvider();
937      var instance = provider.GetDataDescriptors().Where(x => x.Name.Contains("Spatial co-evolution")).Single();
938      var regProblem = new RegressionProblem();
939      regProblem.Load(provider.LoadData(instance));
940      #region Algorithm Configuration
941      gpr.Name = "Gaussian Process Regression";
942      gpr.Description = "A Gaussian process regression algorithm which solves the spatial co-evolution benchmark problem";
943      gpr.Problem = regProblem;
944
945      gpr.CovarianceFunction = new CovarianceSquaredExponentialIso();
946      gpr.MeanFunction = new MeanConst();
947      gpr.MinimizationIterations = 20;
948      gpr.Seed = 0;
949      gpr.SetSeedRandomly = true;
950      #endregion
951      gpr.Engine = new ParallelEngine();
952      return gpr;
953    }
954    #endregion
955
956    #region Scatter Search
957    #region VRP
958    [TestMethod]
959    public void CreateScatterSearchVRPSampleTest() {
960      var ss = CreateScatterSearchVRPSample();
961      XmlGenerator.Serialize(ss, "../../SS_VRP.hl");
962    }
963
964    [TestMethod]
965    public void RunScatterSearchVRPSampleTest() {
966      var ss = CreateScatterSearchVRPSample();
967      ss.SetSeedRandomly.Value = false;
968      RunAlgorithm(ss);
969      Assert.AreEqual(828.93686694283383, GetDoubleResult(ss, "BestQuality"));
970      Assert.AreEqual(868.63623986983077, GetDoubleResult(ss, "CurrentAverageQuality"));
971      Assert.AreEqual(1048.8333559209832, GetDoubleResult(ss, "CurrentWorstQuality"));
972      Assert.AreEqual(262622, GetIntResult(ss, "EvaluatedSolutions"));
973    }
974
975    private ScatterSearch CreateScatterSearchVRPSample() {
976      #region Problem Configuration
977      var provider = new SolomonInstanceProvider();
978      var instance = provider.GetDataDescriptors().Single(x => x.Name == "C101");
979      VehicleRoutingProblem vrpProblem = new VehicleRoutingProblem();
980      vrpProblem.Load(provider.LoadData(instance));
981      #endregion
982
983      #region Algorithm Configuration
984      ScatterSearch ss = new ScatterSearch();
985      ss.Engine = new SequentialEngine();
986      ss.Name = "Scatter Search - VRP";
987      ss.Description = "A scatter search algorithm which solves the \"C101\" vehicle routing problem (imported from Solomon)";
988      ss.Problem = vrpProblem;
989
990      var improver = ss.Problem.Operators.OfType<VRPIntraRouteImprovementOperator>().First();
991      improver.ImprovementAttemptsParameter.Value.Value = 15;
992      improver.SampleSizeParameter.Value.Value = 10;
993      ss.Improver = improver;
994
995      var pathRelinker = ss.Problem.Operators.OfType<VRPPathRelinker>().First();
996      pathRelinker.IterationsParameter.Value.Value = 25;
997      ss.PathRelinker = pathRelinker;
998
999      var similarityCalculator = ss.SimilarityCalculatorParameter.ValidValues.OfType<VRPSimilarityCalculator>().First();
1000      ss.SimilarityCalculator = similarityCalculator;
1001
1002      ss.MaximumIterations.Value = 2;
1003      ss.PopulationSize.Value = 20;
1004      ss.ReferenceSetSize.Value = 10;
1005      ss.Seed.Value = 0;
1006      return ss;
1007      #endregion
1008    }
1009    #endregion
1010    #endregion
1011
1012    #region RAPGA
1013    #region Scheduling
1014    [TestMethod]
1015    public void CreateRAPGASchedulingSampleTest() {
1016      var ss = CreateRAPGASchedulingSample();
1017      XmlGenerator.Serialize(ss, "../../RAPGA_JSSP.hl");
1018    }
1019
1020    [TestMethod]
1021    public void RunRAPGASchedulingSampleTest() {
1022      var rapga = CreateRAPGASchedulingSample();
1023      rapga.SetSeedRandomly.Value = false;
1024      RunAlgorithm(rapga);
1025      Assert.AreEqual(988.00, GetDoubleResult(rapga, "BestQuality"));
1026      Assert.AreEqual(988.00, GetDoubleResult(rapga, "CurrentAverageQuality"));
1027      Assert.AreEqual(988.00, GetDoubleResult(rapga, "CurrentWorstQuality"));
1028      Assert.AreEqual(27100, GetIntResult(rapga, "EvaluatedSolutions"));
1029    }
1030
1031    private RAPGA CreateRAPGASchedulingSample() {
1032      #region Problem Configuration
1033      JobShopSchedulingProblem problem = new JobShopSchedulingProblem();
1034      #endregion
1035
1036      #region Algorithm Configuration
1037      RAPGA rapga = new RAPGA();
1038      rapga.Engine = new SequentialEngine();
1039      rapga.Name = "RAPGA - Job Shop Scheduling";
1040      rapga.Description = "A relevant alleles preserving genetic algorithm which solves a job shop scheduling problem";
1041      rapga.Problem = problem;
1042      rapga.Mutator = rapga.MutatorParameter.ValidValues.OfType<JSMSwapManipulator>().First();
1043      rapga.Seed.Value = 0;
1044      return rapga;
1045      #endregion
1046    }
1047    #endregion
1048    #endregion
1049
1050    #region Helpers
1051    private void ConfigureEvolutionStrategyParameters<R, M, SC, SR, SM>(EvolutionStrategy es, int popSize, int children, int parentsPerChild, int maxGens, bool plusSelection)
1052      where R : ICrossover
1053      where M : IManipulator
1054      where SC : IStrategyParameterCreator
1055      where SR : IStrategyParameterCrossover
1056      where SM : IStrategyParameterManipulator {
1057      es.PopulationSize.Value = popSize;
1058      es.Children.Value = children;
1059      es.ParentsPerChild.Value = parentsPerChild;
1060      es.MaximumGenerations.Value = maxGens;
1061      es.PlusSelection.Value = false;
1062
1063      es.Seed.Value = 0;
1064      es.SetSeedRandomly.Value = true;
1065
1066      es.Recombinator = es.RecombinatorParameter.ValidValues
1067        .OfType<R>()
1068        .Single();
1069
1070      es.Mutator = es.MutatorParameter.ValidValues
1071        .OfType<M>()
1072        .Single();
1073
1074      es.StrategyParameterCreator = es.StrategyParameterCreatorParameter.ValidValues
1075        .OfType<SC>()
1076        .Single();
1077      es.StrategyParameterCrossover = es.StrategyParameterCrossoverParameter.ValidValues
1078        .OfType<SR>()
1079        .Single();
1080      es.StrategyParameterManipulator = es.StrategyParameterManipulatorParameter.ValidValues
1081        .OfType<SM>()
1082        .Single();
1083      es.Engine = new ParallelEngine();
1084    }
1085
1086    private void ConfigureGeneticAlgorithmParameters<S, C, M>(GeneticAlgorithm ga, int popSize, int elites, int maxGens, double mutationRate, int tournGroupSize = 0)
1087      where S : ISelector
1088      where C : ICrossover
1089      where M : IManipulator {
1090      ga.Elites.Value = elites;
1091      ga.MaximumGenerations.Value = maxGens;
1092      ga.MutationProbability.Value = mutationRate;
1093      ga.PopulationSize.Value = popSize;
1094      ga.Seed.Value = 0;
1095      ga.SetSeedRandomly.Value = true;
1096      ga.Selector = ga.SelectorParameter.ValidValues
1097        .OfType<S>()
1098        .First();
1099
1100      ga.Crossover = ga.CrossoverParameter.ValidValues
1101        .OfType<C>()
1102        .First();
1103
1104      ga.Mutator = ga.MutatorParameter.ValidValues
1105        .OfType<M>()
1106        .First();
1107
1108      var tSelector = ga.Selector as TournamentSelector;
1109      if (tSelector != null) {
1110        tSelector.GroupSizeParameter.Value.Value = tournGroupSize;
1111      }
1112      ga.Engine = new ParallelEngine();
1113    }
1114
1115    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)
1116      where S : ISelector
1117      where C : ICrossover
1118      where M : IManipulator
1119      where Mi : IMigrator
1120      where MiS : ISelector
1121      where MiR : IReplacer {
1122      ga.Elites.Value = elites;
1123      ga.MaximumGenerations.Value = maxGens;
1124      ga.MutationProbability.Value = mutationRate;
1125      ga.PopulationSize.Value = popSize;
1126      ga.NumberOfIslands.Value = numberOfIslands;
1127      ga.MigrationInterval.Value = migrationInterval;
1128      ga.MigrationRate.Value = migrationRate;
1129      ga.Seed.Value = 0;
1130      ga.SetSeedRandomly.Value = true;
1131      ga.Selector = ga.SelectorParameter.ValidValues
1132        .OfType<S>()
1133        .Single();
1134
1135      ga.Crossover = ga.CrossoverParameter.ValidValues
1136        .OfType<C>()
1137        .Single();
1138
1139      ga.Mutator = ga.MutatorParameter.ValidValues
1140        .OfType<M>()
1141        .Single();
1142      ga.Migrator = ga.MigratorParameter.ValidValues
1143        .OfType<Mi>()
1144        .Single();
1145      ga.EmigrantsSelector = ga.EmigrantsSelectorParameter.ValidValues
1146        .OfType<MiS>()
1147        .Single();
1148      ga.ImmigrationReplacer = ga.ImmigrationReplacerParameter.ValidValues
1149        .OfType<MiR>()
1150        .Single();
1151      ga.Engine = new ParallelEngine();
1152    }
1153
1154
1155    private void RunAlgorithm(IAlgorithm a) {
1156      var trigger = new EventWaitHandle(false, EventResetMode.ManualReset);
1157      Exception ex = null;
1158      a.Stopped += (src, e) => { trigger.Set(); };
1159      a.ExceptionOccurred += (src, e) => { ex = e.Value; trigger.Set(); };
1160      a.Prepare();
1161      a.Start();
1162      trigger.WaitOne();
1163
1164      Assert.AreEqual(ex, null);
1165    }
1166
1167    private double GetDoubleResult(IAlgorithm a, string resultName) {
1168      return ((DoubleValue)a.Results[resultName].Value).Value;
1169    }
1170    private int GetIntResult(IAlgorithm a, string resultName) {
1171      return ((IntValue)a.Results[resultName].Value).Value;
1172    }
1173    #endregion
1174  }
1175}
Note: See TracBrowser for help on using the repository browser.