Changeset 7724

Timestamp:

04/12/12 16:42:17 (13 years ago)

Author:

jkarder

Message:

#1331:

• added analyzer
• added parameters and adjusted parameter types
• corrected ReferenceSetUpdateMethod
• changed access levels

Location:

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3

Files:

• PopulationRebuildMethod.cs (modified) (2 diffs)
• ReferenceSetUpdateMethod.cs (modified) (1 diff)
• ScatterSearch.cs (modified) (7 diffs)
• ScatterSearchMainLoop.cs (modified) (10 diffs)
• SolutionPoolUpdateMethod.cs (modified) (3 diffs)

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/PopulationRebuildMethod.cs

@@ -39 +39 @@
       get { return (ScopeParameter)Parameters["CurrentScope"]; }
     }
-    public ValueLookupParameter<IntValue> NumberOfHighQualitySolutionsParameter {
+    private ValueLookupParameter<IntValue> NumberOfHighQualitySolutionsParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["NumberOfHighQualitySolutions"]; }
     }
-    public ValueLookupParameter<IntValue> ReferenceSetSizeParameter {
+    private ValueLookupParameter<IntValue> ReferenceSetSizeParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["ReferenceSetSize"]; }
     }
@@ -48 +48 @@
 
     #region Properties
-    public IScope CurrentScope {
+    private IScope CurrentScope {
       get { return CurrentScopeParameter.ActualValue; }
     }
-    public IntValue NumberOfHighQualitySolutions {
+    private IntValue NumberOfHighQualitySolutions {
       get { return NumberOfHighQualitySolutionsParameter.ActualValue; }
       set { NumberOfHighQualitySolutionsParameter.ActualValue = value; }
     }
-    public IntValue ReferenceSetSize {
+    private IntValue ReferenceSetSize {
       get { return ReferenceSetSizeParameter.ActualValue; }
       set { ReferenceSetSizeParameter.ActualValue = value; }

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ReferenceSetUpdateMethod.cs

@@ -93 +93 @@
           foreach (var r in CurrentScope.SubScopes[1].SubScopes) {
             BinaryVector rSol = r.Variables["KnapsackSolution"].Value as BinaryVector;
-            if (pSol != null && rSol != null) {
-              diversity += CalculateDiversity(pSol, rSol);
-            }
-            if (mostDiverseSolution == null || diversity > maxDiversity)
-              mostDiverseSolution = p;
+            if (pSol != null && rSol != null) diversity += CalculateDiversity(pSol, rSol);
+          }
+          if (mostDiverseSolution == null || diversity > maxDiversity) {
+            mostDiverseSolution = p;
+            maxDiversity = diversity;
           }
         }

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearch.cs

@@ -37 +37 @@
 
 namespace HeuristicLab.Algorithms.ScatterSearch {
+  /// <summary>
+  /// A scatter search algorithm.
+  /// </summary>
   [Item("Scatter Search", "A scatter search algorithm.")]
   [Creatable("Algorithms")]
@@ -263 +266 @@
       base.OnProblemChanged();
     }
-
     protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
       ParameterizeStochasticOperator(Problem.SolutionCreator);
@@ -269 +271 @@
       base.Problem_SolutionCreatorChanged(sender, e);
     }
-
     protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
       ParameterizeStochasticOperator(Problem.Evaluator);
@@ -280 +281 @@
       base.Problem_EvaluatorChanged(sender, e);
     }
-
     protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
       foreach (IOperator op in Problem.Operators) ParameterizeStochasticOperator(op);
@@ -393 +393 @@
         foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
           foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
-            param.Depth = 0;
+            param.Depth = 1;
           Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
         }
@@ -409 +409 @@
     private void ParameterizeMainLoop() {
       if (Problem != null) {
-        //MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
-        //MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
-        //MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
-      }
-      if (MoveEvaluator != null) ;
-      //MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
+        MainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      }
+      if (MoveEvaluator != null)
+        MainLoop.MoveQualityParameter.ActualName = MoveEvaluator.MoveQualityParameter.ActualName;
     }
     private void ParameterizeStochasticOperator(IOperator op) {
@@ -476 +476 @@
       }
     }
-
     private ScatterSearchMainLoop FindMainLoop(IOperator start) {
       IOperator mainLoop = start;

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/ScatterSearchMainLoop.cs

@@ -47 +47 @@
       get { return (LookupParameter<IntValue>)Parameters["MaximumIterations"]; }
     }
+    internal LookupParameter<BoolValue> MaximizationParameter {
+      get { return (LookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
     internal LookupParameter<IntValue> SampleSizeParameter {
       get { return (LookupParameter<IntValue>)Parameters["SampleSize"]; }
@@ -59 +62 @@
       get { return (LookupParameter<IntValue>)Parameters["NumberOfHighQualitySolutions"]; }
     }
+    internal LookupParameter<DoubleValue> QualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    internal LookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    internal LookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (LookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
     internal LookupParameter<VariableCollection> ResultsParameter {
       get { return (LookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    internal LookupParameter<IOperator> MoveEvaluatorParameter {
+      get { return (LookupParameter<IOperator>)Parameters["MoveEvaluator"]; }
+    }
+    internal LookupParameter<IOperator> MoveGeneratorParameter {
+      get { return (LookupParameter<IOperator>)Parameters["MoveGenerator"]; }
+    }
+    internal LookupParameter<IOperator> MoveMakerParameter {
+      get { return (LookupParameter<IOperator>)Parameters["MoveMaker"]; }
     }
     internal LookupParameter<IMultiAnalyzer> AnalyzerParameter {
@@ -80 +101 @@
       set { MaximumIterationsParameter.ActualValue = value; }
     }
+    public BoolValue Maximization {
+      get { return MaximizationParameter.ActualValue; }
+      set { MaximizationParameter.ActualValue = value; }
+    }
     public IntValue SampleSize {
       get { return SampleSizeParameter.ActualValue; }
@@ -96 +121 @@
       set { NumberOfHighQualitySolutionsParameter.ActualValue = value; }
     }
+    public DoubleValue Quality {
+      get { return QualityParameter.ActualValue; }
+      set { QualityParameter.ActualValue = value; }
+    }
+    public DoubleValue BestKnownQuality {
+      get { return BestKnownQualityParameter.ActualValue; }
+      set { BestKnownQualityParameter.ActualValue = value; }
+    }
+    public DoubleValue MoveQuality {
+      get { return MoveQualityParameter.ActualValue; }
+      set { MoveQualityParameter.ActualValue = value; }
+    }
     public VariableCollection Results {
       get { return ResultsParameter.ActualValue; }
       set { ResultsParameter.ActualValue = value; }
+    }
+    public IOperator MoveEvaluator {
+      get { return MoveEvaluatorParameter.ActualValue; }
+      set { MoveEvaluatorParameter.ActualValue = value; }
+    }
+    public IOperator MoveGenerator {
+      get { return MoveGeneratorParameter.ActualValue; }
+      set { MoveGeneratorParameter.ActualValue = value; }
+    }
+    public IOperator MoveMaker {
+      get { return MoveMakerParameter.ActualValue; }
+      set { MoveMakerParameter.ActualValue = value; }
     }
     public IMultiAnalyzer Analyzer {
@@ -120 +169 @@
       Parameters.Add(new LookupParameter<IntValue>("Iterations", "The number of iterations performed."));
       Parameters.Add(new LookupParameter<IntValue>("MaximumIterations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
       Parameters.Add(new LookupParameter<IntValue>("SampleSize", "Number of moves that MultiMoveGenerators should create. This is ignored for Exhaustive- and SingleMoveGenerators."));
       Parameters.Add(new LookupParameter<IntValue>("PopulationSize", "The size of the population."));
       Parameters.Add(new LookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
       Parameters.Add(new LookupParameter<IntValue>("NumberOfHighQualitySolutions", "The number of high quality solutions that should be added to the reference set."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new LookupParameter<DoubleValue>("BestKnownQuality", "The problem's best known quality value found so far."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The value which represents the quality of a move."));
       Parameters.Add(new LookupParameter<IOperator>("SolutionCreator", "The operator which is used to create new solutions."));
       Parameters.Add(new LookupParameter<IOperator>("Evaluator", "The operator which is used to evaluate new solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
@@ -143 +196 @@
       IntCounter interationsCounter = new IntCounter();
       LocalSearchImprovementOperator localImprovementOperator = new LocalSearchImprovementOperator();
+      Placeholder analyzer = new Placeholder();
       Placeholder solutionImprover = new Placeholder();
       Placeholder solutionEvaluator = new Placeholder();
@@ -204 +258 @@
       interationsCounter.Successor = resultsCollector;
 
+      analyzer.Name = "Analyzer";
+      analyzer.OperatorParameter.ActualName = "Analyzer";
+
       solutionImprover.Name = "SolutionImprover";
       solutionImprover.OperatorParameter.ActualName = "LocalImprovementOperator";
@@ -214 +271 @@
       populationRebuildMethod.Successor = subScopesProcessor3;
 
+      resultsCollector.CopyValue = new BoolValue(false);
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>(IterationsParameter.Name));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(BestKnownQualityParameter.Name, null, BestKnownQualityParameter.Name));
       resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
       resultsCollector.Successor = iterationsChecker;
@@ -221 +280 @@
 
       solutionCombinationMethod.Successor = subScopesProcessor2;
+
+      solutionPoolUpdateMethod.Successor = analyzer;
 
       solutionsCreator.Name = "DiversificationGenerationMethod";
@@ -257 +318 @@
 
     public override IOperation Apply() {
+      if (MoveGeneratorParameter.ActualValue == null || MoveEvaluatorParameter.ActualValue == null || MoveMakerParameter.ActualValue == null)
+        return null;
       return base.Apply();
     }

branches/ScatterSearch/HeuristicLab.Algorithms.ScatterSearch/3.3/SolutionPoolUpdateMethod.cs

@@ -42 +42 @@
       get { return (ValueLookupParameter<BoolValue>)Parameters["NewSolutions"]; }
     }
+    private ValueLookupParameter<IntValue> ReferenceSetSizeParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["ReferenceSetSize"]; }
+    }
     #endregion
 
     #region Properties
-    public IScope CurrentScope {
+    private IScope CurrentScope {
       get { return CurrentScopeParameter.ActualValue; }
     }
-    public BoolValue NewSolutions {
+    private BoolValue NewSolutions {
       get { return NewSolutionsParameter.ActualValue; }
+    }
+    private IntValue ReferenceSetSize {
+      get { return ReferenceSetSizeParameter.ActualValue; }
+      set { ReferenceSetSizeParameter.ActualValue = value; }
     }
     #endregion
@@ -64 +71 @@
     private void Initialize() {
       #region Create parameters
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new solutions are added as sub-scopes."));
       Parameters.Add(new ValueLookupParameter<BoolValue>("NewSolutions", "Indicates if new solutions have been found."));
-      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new solutions are added as sub-scopes."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("ReferenceSetSize", "The size of the reference set."));
       #endregion
 
@@ -86 +94 @@
       if ((offspring.SubScopes.OrderByDescending(o => o.Variables["Quality"].Value).First().Variables["Quality"].Value as DoubleValue).Value
           > (parents.SubScopes.OrderByDescending(o => o.Variables["Quality"].Value).First().Variables["Quality"].Value as DoubleValue).Value) {
-        CurrentScope.SubScopes.Replace(CurrentScope.SubScopes.Union(offspring.SubScopes).OrderByDescending(o => o.Variables["Quality"].Value).Take(10));
+        CurrentScope.SubScopes.Replace(CurrentScope.SubScopes.Union(offspring.SubScopes).OrderByDescending(o => o.Variables["Quality"].Value).Take(ReferenceSetSize.Value));
         NewSolutions.Value = true;
       }