Free cookie consent management tool by TermsFeed Policy Generator

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

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

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