Free cookie consent management tool by TermsFeed Policy Generator

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

Last change on this file since 7863 was 7863, checked in by sforsten, 12 years ago

#1784: changed name of the DataDescriptor in the SamplesTest for regression and classification

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