Changeset 8086 for branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch

Timestamp:

06/22/12 11:11:38 (12 years ago)

Author:

jkarder

Message:

#1331:

• synced branch with trunk
• added custom interface (ISimilarityBasedOperator) to mark operators that conduct similarity calculation
• similarity calculators are now parameterized by the algorithm
• deleted SolutionPool2TierUpdateMethod
• deleted KnapsackMultipleGuidesPathRelinker
• moved IImprovementOperator, IPathRelinker and ISimilarityCalculator to HeuristicLab.Optimization
• added parameter descriptions
• fixed plugin references
• fixed count of EvaluatedSolutions
• fixed check for duplicate solutions
• minor code improvements

Location:

branches/ScatterSearch (trunk integration)

Files:

• . (modified) (2 props)
• HeuristicLab.Algorithms.ScatterSearch/3.3/HeuristicLab.Algorithms.ScatterSearch-3.3.csproj (modified) (4 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/IScatterSearchOperator.cs (modified) (2 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/OffspringProcessor.cs (modified) (1 diff)
• HeuristicLab.Algorithms.ScatterSearch/3.3/Plugin.cs.frame (modified) (2 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/PopulationRebuildMethod.cs (modified) (1 diff)
• HeuristicLab.Algorithms.ScatterSearch/3.3/ReferenceSetUpdateMethod.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs (modified) (9 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs (modified) (10 diffs)
• HeuristicLab.Algorithms.ScatterSearch/3.3/SolutionPool2TierUpdateMethod.cs (deleted)
• HeuristicLab.Algorithms.ScatterSearch/3.3/SolutionPoolUpdateMethod.cs (modified) (7 diffs)

branches/ScatterSearch (trunk integration)

@@ -20 +20 @@
 bin
 protoc.exe
+_ReSharper.HeuristicLab 3.3 Tests

@@ -20 +20 @@
 bin
 protoc.exe
+_ReSharper.HeuristicLab 3.3 Tests

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/HeuristicLab.Algorithms.ScatterSearch-3.3.csproj

@@ -58 +58 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Encodings.BinaryVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.PermutationEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Operators-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Optimization-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Parameters-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
@@ -84 +73 @@
     </Reference>
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.Knapsack-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.TestFunctions-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Problems.TravelingSalesman-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <Private>False</Private>
     </Reference>
@@ -112 +92 @@
   <ItemGroup>
     <Compile Include="IScatterSearchOperator.cs" />
-    <Compile Include="SolutionPool2TierUpdateMethod.cs" />
     <Compile Include="OffspringProcessor.cs" />
     <None Include="HeuristicLab.snk" />
@@ -124 +103 @@
     <Compile Include="ScatterSearchMainLoop.cs" />
     <Compile Include="SolutionPoolUpdateMethod.cs" />
-  </ItemGroup>
-  <ItemGroup />
-  <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
-      <Project>{25087811-F74C-4128-BC86-8324271DA13E}</Project>
-      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/IScatterSearchOperator.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using HeuristicLab.Common;
 using HeuristicLab.Core;
 
@@ -28 +26 @@
   /// An interface which represents a scatter search specific operator.
   /// </summary>
-  public interface IScatterSearchOperator : IOperator, IParameterizedNamedItem, IDeepCloneable, ICloneable {
-  }
+  public interface IScatterSearchOperator : IOperator { }
 }

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/OffspringProcessor.cs

@@ -57 +57 @@
       : base() {
       #region Create parameters
-      Parameters.Add(new ScopeParameter("CurrentScope"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the offspring as variables."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Target", "This parameter is used for name translation only."));
       #endregion
     }

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/Plugin.cs.frame

@@ -33 +33 @@
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.BinaryVectorEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.PermutationEncoding", "3.3")]
-  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
   [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
@@ -41 +38 @@
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.Knapsack", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.TestFunctions", "3.3")]
-  [PluginDependency("HeuristicLab.Problems.TravelingSalesman", "3.3")]
   [PluginDependency("HeuristicLab.Random", "3.3")]
   [PluginDependency("HeuristicLab.Selection", "3.3")]

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/PopulationRebuildMethod.cs

@@ -80 +80 @@
       : base() {
       #region Create parameters
-      Parameters.Add(new ScopeParameter("CurrentScope"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfHighQualitySolutions"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Quality"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize"));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the population and the reference set."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Quality", "This parameter is used for name translation only."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
       #endregion
     }

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/ReferenceSetUpdateMethod.cs

@@ -26 +26 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
@@ -36 +37 @@
   [Item("ReferenceSetUpdateMethod", "An operator that updates the reference set.")]
   [StorableClass]
-  public sealed class ReferenceSetUpdateMethod : SingleSuccessorOperator, IScatterSearchOperator {
+  public sealed class ReferenceSetUpdateMethod : SingleSuccessorOperator, ISimilarityBasedOperator {
+    #region ISimilarityBasedOperator Members
+    public ISimilarityCalculator SimilarityCalculator { get; set; }
+    #endregion
+
     #region Parameter properties
     public ScopeParameter CurrentScopeParameter {
@@ -43 +48 @@
     public IValueLookupParameter<IntValue> ReferenceSetSizeParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["ReferenceSetSize"]; }
-    }
-    public IValueLookupParameter<SimilarityCalculator> SimilarityCalculatorParameter {
-      get { return (IValueLookupParameter<SimilarityCalculator>)Parameters["SimilarityCalculator"]; }
-    }
-    public IValueLookupParameter<IItem> TargetParameter {
-      get { return (IValueLookupParameter<IItem>)Parameters["Target"]; }
     }
     #endregion
@@ -59 +58 @@
       get { return ReferenceSetSizeParameter.ActualValue; }
     }
-    private SimilarityCalculator SimilarityCalculator {
-      get { return SimilarityCalculatorParameter.ActualValue; }
-    }
-    private IItem Target {
-      get { return TargetParameter.ActualValue; }
-    }
     #endregion
 
@@ -73 +66 @@
       : base() {
       #region Create parameters
-      Parameters.Add(new ScopeParameter("CurrentScope"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize"));
-      Parameters.Add(new ValueLookupParameter<SimilarityCalculator>("SimilarityCalculator"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the population and the reference set."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
       #endregion
     }

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs

@@ -174 +174 @@
       : base() {
       #region Create parameters
-      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", new MultiAnalyzer()));
-      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover"));
-      Parameters.Add(new ValueParameter<BoolValue>("ExecutePathRelinking", new BoolValue(true)));
-      Parameters.Add(new ConstrainedValueParameter<IImprovementOperator>("Improver"));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("NumberOfHighQualitySolutions", new IntValue(10)));
-      Parameters.Add(new ConstrainedValueParameter<IPathRelinker>("PathRelinker"));
-      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", new IntValue(300)));
-      Parameters.Add(new ValueParameter<IntValue>("ReferenceSetSize", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("Seed", new IntValue(0)));
-      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", new BoolValue(true)));
-      Parameters.Add(new ConstrainedValueParameter<ISimilarityCalculator>("SimilarityCalculator"));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration.", new MultiAnalyzer()));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueParameter<BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ConstrainedValueParameter<IImprovementOperator>("Improver", "The operator used to improve solutions."));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set.", new IntValue(5)));
+      Parameters.Add(new ConstrainedValueParameter<IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
+      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(50)));
+      Parameters.Add(new ValueParameter<IntValue>("ReferenceSetSize", "The size of the reference set.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ConstrainedValueParameter<ISimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
       #endregion
 
@@ -194 +194 @@
       Placeholder solutionEvaluator = new Placeholder();
       Placeholder solutionImprover = new Placeholder();
-      SubScopesCounter subScopesCounter = new SubScopesCounter();
+      VariableCreator variableCreator = new VariableCreator();
+      DataReducer dataReducer = new DataReducer();
       ResultsCollector resultsCollector = new ResultsCollector();
       BestSelector bestSelector = new BestSelector();
@@ -212 +213 @@
 
       uniformSubScopesProcessor.Operator = solutionImprover;
-      uniformSubScopesProcessor.Successor = subScopesCounter;
+      uniformSubScopesProcessor.Successor = variableCreator;
 
       solutionImprover.Name = "SolutionImprover";
@@ -222 +223 @@
       solutionEvaluator.Successor = null;
 
-      subScopesCounter.Name = "Initialize EvaluatedSolutions";
-      subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
-      subScopesCounter.Successor = resultsCollector;
+      variableCreator.Name = "Initialize EvaluatedSolutions";
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("EvaluatedSolutions", new IntValue()));
+      variableCreator.Successor = dataReducer;
+
+      dataReducer.Name = "Increment EvaluatedSolutions";
+      dataReducer.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
+      dataReducer.TargetParameter.ActualName = "EvaluatedSolutions";
+      dataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      dataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      dataReducer.Successor = resultsCollector;
 
       resultsCollector.Name = "ResultsCollector";
@@ -239 +247 @@
       mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
       mainLoop.IterationsParameter.ActualName = "Iterations";
+      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
       mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
       mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
@@ -261 +270 @@
       ParameterizeStochasticOperator(Problem.SolutionCreator);
       ParameterizeStochasticOperator(Problem.Evaluator);
-      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
       ParameterizeAnalyzers();
       ParameterizeSolutionsCreator();
@@ -289 +298 @@
     }
     protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
-      foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
       UpdateAnalyzers();
       UpdateCrossovers();
@@ -376 +385 @@
       ISimilarityCalculator defaultDiversityCalculator = Problem.Operators.OfType<ISimilarityCalculator>().FirstOrDefault();
 
-      foreach (ISimilarityCalculator diversityCalculator in Problem.Operators.OfType<ISimilarityCalculator>().OrderBy(x => x.Name))
+      foreach (ISimilarityCalculator diversityCalculator in Problem.Operators.OfType<ISimilarityCalculator>())
         SimilarityCalculatorParameter.ValidValues.Add(diversityCalculator);
 
@@ -401 +410 @@
         MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
         MainLoop.TargetParameter.ActualName = Improver.TargetParameter.ActualName;
-        foreach (var item in MainLoop.OperatorGraph.Operators.OfType<IScatterSearchOperator>()) {
+        foreach (var op in MainLoop.OperatorGraph.Operators.OfType<IScatterSearchOperator>()) {
           // parameter should be accessed direclty (using an interface definition)
-          PropertyInfo propInfo = item.GetType().GetProperty(MainLoop.TargetParameter.Name + "Parameter");
+          PropertyInfo propInfo = op.GetType().GetProperty(MainLoop.TargetParameter.Name + "Parameter");
           if (propInfo != null && propInfo.CanRead)
-            (propInfo.GetValue(item, null) as IValueLookupParameter<IItem>).ActualName = MainLoop.TargetParameter.ActualName;
-          propInfo = item.GetType().GetProperty(MainLoop.QualityParameter.Name + "Parameter");
+            (propInfo.GetValue(op, null) as IValueLookupParameter<IItem>).ActualName = MainLoop.TargetParameter.ActualName;
+          propInfo = op.GetType().GetProperty(MainLoop.QualityParameter.Name + "Parameter");
           if (propInfo != null && propInfo.CanRead)
-            (propInfo.GetValue(item, null) as IValueLookupParameter<IItem>).ActualName = MainLoop.QualityParameter.ActualName;
+            (propInfo.GetValue(op, null) as IValueLookupParameter<IItem>).ActualName = MainLoop.QualityParameter.ActualName;
         }
+        foreach (ISimilarityBasedOperator op in MainLoop.OperatorGraph.Operators.OfType<ISimilarityBasedOperator>())
+          op.SimilarityCalculator = SimilarityCalculator;
       }
     }

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs

@@ -92 +92 @@
       get { return (IValueLookupParameter<ISimilarityCalculator>)Parameters["SimilarityCalculator"]; }
     }
-    public IValueLookupParameter<ISolutionCreator> SolutionCreatorParameter {
-      get { return (IValueLookupParameter<ISolutionCreator>)Parameters["SolutionCreator"]; }
-    }
     public IValueLookupParameter<IItem> TargetParameter {
       get { return (IValueLookupParameter<IItem>)Parameters["Target"]; }
@@ -173 +170 @@
       set { SimilarityCalculatorParameter.ActualValue = value; }
     }
-    private ISolutionCreator SolutionCreator {
-      get { return SolutionCreatorParameter.ActualValue; }
-      set { SolutionCreatorParameter.ActualValue = value; }
-    }
     private IItem Target {
       get { return TargetParameter.ActualValue; }
@@ -194 +187 @@
     private void Initialize() {
       #region Create parameters
-      Parameters.Add(new ValueLookupParameter<IMultiAnalyzer>("Analyzer"));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality"));
-      Parameters.Add(new ValueLookupParameter<ICrossover>("Crossover"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions"));
-      Parameters.Add(new ValueLookupParameter<IEvaluator>("Evaluator"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("ExecutePathRelinking"));
-      Parameters.Add(new ValueLookupParameter<IImprovementOperator>("Improver"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Iterations"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfHighQualitySolutions"));
-      Parameters.Add(new ValueLookupParameter<IPathRelinker>("PathRelinker"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize"));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("Quality"));
-      Parameters.Add(new ValueLookupParameter<IRandom>("Random"));
-      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results"));
-      Parameters.Add(new ValueLookupParameter<ISimilarityCalculator>("SimilarityCalculator"));
-      Parameters.Add(new ValueLookupParameter<ISolutionCreator>("SolutionCreator"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
+      Parameters.Add(new ValueLookupParameter<IMultiAnalyzer>("Analyzer", "The analyzer used to analyze each iteration."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
+      Parameters.Add(new ValueLookupParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
+      Parameters.Add(new ValueLookupParameter<IEvaluator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ExecutePathRelinking", "True if path relinking should be executed instead of crossover, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<IImprovementOperator>("Improver", "The operator used to improve solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Iterations", "The number of iterations performed."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions in the reference set."));
+      Parameters.Add(new ValueLookupParameter<IPathRelinker>("PathRelinker", "The operator used to execute path relinking."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Quality", "This parameter is used for name translation only."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
+      Parameters.Add(new ValueLookupParameter<ISimilarityCalculator>("SimilarityCalculator", "The operator used to calculate the similarity between two solutions."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Target", "This parameter is used for name translation only."));
       #endregion
 
@@ -239 +231 @@
       SolutionPoolUpdateMethod solutionPoolUpdateMethod = new SolutionPoolUpdateMethod();
       SolutionsCreator solutionsCreator = new SolutionsCreator();
-      SubScopesCounter subScopesCounter1 = new SubScopesCounter();
-      SubScopesCounter subScopesCounter2 = new SubScopesCounter();
+      DataReducer dataReducer1 = new DataReducer();
+      DataReducer dataReducer2 = new DataReducer();
       SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
       SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
       SubScopesProcessor subScopesProcessor3 = new SubScopesProcessor();
+      SubScopesProcessor subScopesProcessor4 = new SubScopesProcessor();
       ConditionalBranch terminateBranch = new ConditionalBranch();
       UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
@@ -253 +246 @@
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>(IterationsParameter.Name, new IntValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("NewSolutions", new BoolValue(false)));
       variableCreator.Successor = resultsCollector;
@@ -264 +257 @@
       iterationsChecker.Name = "IterationsChecker";
       iterationsChecker.Comparison.Value = ComparisonType.GreaterOrEqual;
-      iterationsChecker.LeftSideParameter.ActualName = "Iterations";
-      iterationsChecker.RightSideParameter.ActualName = "MaximumIterations";
+      iterationsChecker.LeftSideParameter.ActualName = IterationsParameter.Name;
+      iterationsChecker.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
       iterationsChecker.ResultParameter.ActualName = "Terminate";
       iterationsChecker.Successor = terminateBranch;
@@ -273 +266 @@
       terminateBranch.FalseBranch = referenceSetUpdateMethod;
 
-      referenceSetUpdateMethod.TargetParameter.ActualName = TargetParameter.ActualName;
       referenceSetUpdateMethod.Successor = assigner1;
 
@@ -305 +297 @@
 
       pathRelinker.Name = "PathRelinker";
-      pathRelinker.OperatorParameter.ActualName = "PathRelinker";
+      pathRelinker.OperatorParameter.ActualName = PathRelinkerParameter.Name;
       pathRelinker.Successor = offspringProcessor;
 
       crossover.Name = "Crossover";
-      crossover.OperatorParameter.ActualName = "Crossover";
+      crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
       crossover.Successor = offspringProcessor;
 
@@ -326 +318 @@
       uniformSubScopesProcessor2.DepthParameter.Value = new IntValue(2);
       uniformSubScopesProcessor2.Operator = solutionImprover1;
-      uniformSubScopesProcessor2.Successor = subScopesCounter1;
+      uniformSubScopesProcessor2.Successor = subScopesProcessor4;
 
       solutionImprover1.Name = "SolutionImprover";
-      solutionImprover1.OperatorParameter.ActualName = "Improver";
+      solutionImprover1.OperatorParameter.ActualName = ImproverParameter.Name;
       solutionImprover1.Successor = solutionEvaluator1;
 
       solutionEvaluator1.Name = "SolutionEvaluator";
-      solutionEvaluator1.OperatorParameter.ActualName = "Evaluator";
-
-      subScopesCounter1.Name = "Increment EvaluatedSolutions";
-      subScopesCounter1.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      solutionEvaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      subScopesProcessor4.Operators.Add(dataReducer1);
+
+      dataReducer1.Name = "Increment EvaluatedSolutions";
+      dataReducer1.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
+      dataReducer1.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      dataReducer1.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      dataReducer1.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
 
       solutionPoolUpdateMethod.QualityParameter.ActualName = QualityParameter.ActualName;
-      solutionPoolUpdateMethod.TargetParameter.ActualName = TargetParameter.ActualName;
       solutionPoolUpdateMethod.Successor = analyzer;
 
       analyzer.Name = "Analyzer";
-      analyzer.OperatorParameter.ActualName = "Analyzer";
+      analyzer.OperatorParameter.ActualName = AnalyzerParameter.Name;
 
       newSolutionsBranch.Name = "NewSolutionsChecker";
@@ -359 +355 @@
 
       solutionsCreator.Name = "DiversificationGenerationMethod";
-      solutionsCreator.NumberOfSolutionsParameter.ActualName = "PopulationSize";
+      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
       solutionsCreator.Successor = uniformSubScopesProcessor3;
 
       uniformSubScopesProcessor3.DepthParameter.Value = new IntValue(1);
       uniformSubScopesProcessor3.Operator = solutionImprover2;
-      uniformSubScopesProcessor3.Successor = subScopesCounter2;
+      uniformSubScopesProcessor3.Successor = dataReducer2;
 
       solutionImprover2.Name = "SolutionImprover";
-      solutionImprover2.OperatorParameter.ActualName = "Improver";
+      solutionImprover2.OperatorParameter.ActualName = ImproverParameter.Name;
       solutionImprover2.Successor = solutionEvaluator2;
 
       solutionEvaluator2.Name = "SolutionEvaluator";
-      solutionEvaluator2.OperatorParameter.ActualName = "Evaluator";
-
-      subScopesCounter2.Name = "Increment EvaluatedSolutions";
-      subScopesCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      solutionEvaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      dataReducer2.Name = "Increment EvaluatedSolutions";
+      dataReducer2.ParameterToReduce.ActualName = "LocalEvaluatedSolutions";
+      dataReducer2.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      dataReducer2.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      dataReducer2.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
 
       iterationsCounter.Name = "IterationCounter";
       iterationsCounter.IncrementParameter.Value = new IntValue(1);
-      iterationsCounter.ValueParameter.ActualName = "Iterations";
+      iterationsCounter.ValueParameter.ActualName = IterationsParameter.Name;
       iterationsCounter.Successor = resultsCollector;
       #endregion

branches/ScatterSearch (trunk integration)/HeuristicLab.Algorithms.ScatterSearch/3.3/SolutionPoolUpdateMethod.cs

@@ -27 +27 @@
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
@@ -37 +38 @@
   [Item("SolutionPoolUpdateMethod", "An operator that updates the solution pool.")]
   [StorableClass]
-  public sealed class SolutionPoolUpdateMethod : SingleSuccessorOperator, IScatterSearchOperator {
+  public sealed class SolutionPoolUpdateMethod : SingleSuccessorOperator, IScatterSearchOperator, ISimilarityBasedOperator {
+    #region ISimilarityBasedOperator Members
+    public ISimilarityCalculator SimilarityCalculator { get; set; }
+    #endregion
+
     #region Parameter properties
     public ScopeParameter CurrentScopeParameter {
@@ -53 +58 @@
     public IValueLookupParameter<IntValue> ReferenceSetSizeParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["ReferenceSetSize"]; }
-    }
-    public IValueLookupParameter<SimilarityCalculator> SimilarityCalculatorParameter {
-      get { return (IValueLookupParameter<SimilarityCalculator>)Parameters["SimilarityCalculator"]; }
-    }
-    public IValueLookupParameter<IItem> TargetParameter {
-      get { return (IValueLookupParameter<IItem>)Parameters["Target"]; }
     }
     #endregion
@@ -80 +79 @@
       set { ReferenceSetSizeParameter.ActualValue = value; }
     }
-    private SimilarityCalculator SimilarityCalculator {
-      get { return SimilarityCalculatorParameter.ActualValue; }
-    }
-    private IItem Target {
-      get { return TargetParameter.ActualValue; }
-    }
     #endregion
 
@@ -99 +92 @@
     private void Initialize() {
       #region Create parameters
-      Parameters.Add(new ScopeParameter("CurrentScope"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization"));
-      Parameters.Add(new ValueLookupParameter<BoolValue>("NewSolutions"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Quality"));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize"));
-      Parameters.Add(new ValueLookupParameter<SimilarityCalculator>("SimilarityCalculator"));
-      Parameters.Add(new ValueLookupParameter<IItem>("Target"));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that is the reference set."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("NewSolutions", "True if new solutions have been found, otherwise false."));
+      Parameters.Add(new ValueLookupParameter<IItem>("Quality", "This parameter is used for name translation only."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
       #endregion
     }
 
     public override IOperation Apply() {
-      IScope parentsScope = new Scope("Parents");
-      IScope offspringScope = new Scope("Offspring");
+      ScopeList parents = new ScopeList();
+      ScopeList offspring = new ScopeList();
 
       // split parents and offspring
       foreach (var scope in CurrentScope.SubScopes) {
-        parentsScope.SubScopes.AddRange(scope.SubScopes.Take(scope.SubScopes.Count - 1));
-        offspringScope.SubScopes.AddRange(scope.SubScopes.Last().SubScopes);
+        parents.AddRange(scope.SubScopes.Take(scope.SubScopes.Count - 1));
+        offspring.AddRange(scope.SubScopes.Last().SubScopes);
       }
 
       CurrentScope.SubScopes.Clear();
 
-      var orderedParents = Maximization.Value ? parentsScope.SubScopes.OrderByDescending(x => x.Variables[QualityParameter.ActualName].Value) :
-                                                parentsScope.SubScopes.OrderBy(x => x.Variables[QualityParameter.ActualName].Value);
-      var orderedOffspring = Maximization.Value ? offspringScope.SubScopes.OrderByDescending(x => x.Variables[QualityParameter.ActualName].Value) :
-                                                  offspringScope.SubScopes.OrderBy(x => x.Variables[QualityParameter.ActualName].Value);
+      // attention: assumes that parents are distinct
+      // distinction might cause a too small reference set (e.g. reference set = {1, 2, 2, 2,..., 2} -> union = {1, 2}
+
+      var orderedParents = Maximization.Value ? parents.OrderByDescending(x => x.Variables[QualityParameter.ActualName].Value) :
+                                                parents.OrderBy(x => x.Variables[QualityParameter.ActualName].Value);
+      var orderedOffspring = Maximization.Value ? offspring.OrderByDescending(x => x.Variables[QualityParameter.ActualName].Value) :
+                                                  offspring.OrderBy(x => x.Variables[QualityParameter.ActualName].Value);
 
       CurrentScope.SubScopes.AddRange(orderedParents);
@@ -136 +130 @@
       if (orderedOffspring.Any(hasBetterQuality)) {
         // produce the set union
-        // attention: distinction might cause a too small reference set! (e.g. reference set = {1, 2, 2, 2, ..., 2} -> union = {1, 2}
         var union = orderedParents.Union(orderedOffspring.Where(hasBetterQuality), new SolutionEqualityComparer<IScope>(SimilarityCalculator.ExecuteCalculation));
-        if (union.Count() > orderedParents/*.Distinct(new KeyEqualityComparer<IScope>(x => x.Variables[TargetParameter.ActualName].Value.ToString()))*/.Count()) {
+        if (union.Count() > orderedParents.Count()) {
           var orderedUnion = Maximization.Value ? union.OrderByDescending(x => x.Variables[QualityParameter.ActualName].Value) :
                                                   union.OrderBy(x => x.Variables[QualityParameter.ActualName].Value);
-          CurrentScope.SubScopes.Replace(orderedUnion.Take(ReferenceSetSize.Value).ToList());
+          CurrentScope.SubScopes.Replace(orderedUnion.Take(ReferenceSetSize.Value));
           NewSolutions.Value = true;
         }
@@ -149 +142 @@
     }
 
-    private class SolutionEqualityComparer<T> : EqualityComparer<T> {
-      private readonly Func<T, T, double> diversityCalculator;
+    public class SolutionEqualityComparer<T> : EqualityComparer<T> {
+      private readonly Func<T, T, double> similarityCalculator;
 
-      public SolutionEqualityComparer(Func<T, T, double> diversityCalculator) {
-        this.diversityCalculator = diversityCalculator;
+      public SolutionEqualityComparer(Func<T, T, double> similarityCalculator) {
+        this.similarityCalculator = similarityCalculator;
       }
 
       public override bool Equals(T x, T y) {
-        return diversityCalculator(x, y) == 0.0;
+        if (object.ReferenceEquals(x, y)) return true;
+        if (x == null || y == null) return false;
+        return similarityCalculator(x, y) == 1.0;
       }
 
       public override int GetHashCode(T obj) {
-        return obj.GetHashCode();
+        return 0; // return the same hash code for each object, otherwise Equals will not be called
       }
     }

@@ -20 +20 @@
 bin
 protoc.exe
+_ReSharper.HeuristicLab 3.3 Tests