Changeset 11363 for branches/SimSharp/HeuristicLab.Problems.Programmable/3.3

Timestamp:

09/15/14 10:23:34 (10 years ago)

Author:

abeham

Message:

#2174:

• Removed SimSharp reference (not the purpose of this branch anymore)
• Fixed bugs regarding parameter names when no parameter have been defined
• Added a method to the problem definition to retrieve a neighborhood solution
  • Programmable problem now works with LocalSearch and SimulatedAnnealing

Location:

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3

Files:

• Datastructures/IntegerParameterConfiguration.cs (modified) (1 diff)
• Datastructures/ParameterVector.cs (modified) (7 diffs)
• Datastructures/RealParameterConfiguration.cs (modified) (1 diff)
• HeuristicLab.Problems.Programmable-3.3.csproj (modified) (2 diffs)
• Interfaces/IParameterVectorMoveOperator.cs (added)
• Interfaces/ISingleObjectiveProblemDefinition.cs (modified) (2 diffs)
• Operators/ParameterVectorMoveEvaluator.cs (added)
• Operators/ParameterVectorMoveGenerator.cs (added)
• Operators/ParameterVectorMoveMaker.cs (added)
• SingleObjectiveProgrammableProblem.cs (modified) (2 diffs)
• SingleObjectiveScript.cs (modified) (2 diffs)

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/IntegerParameterConfiguration.cs

@@ -74 +74 @@
       if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
       if (step != null && min.Count != step.Count) throw new ArgumentException("step must be of the same length as min or null", "step");
-      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
       this.length = new IntValue(length);
       bounds = new IntMatrix(min.Count, step != null ? 3 : 2);

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/ParameterVector.cs

@@ -22 +22 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
@@ -28 +29 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public class ParameterVector {
-    protected Dictionary<string, BinaryVector> BinaryParameters;
-    protected Dictionary<string, IntegerVector> IntegerParameters;
-    protected Dictionary<string, RealVector> RealParameters;
-    protected Dictionary<string, Permutation> PermutationParameters;
+  public sealed class ParameterVector : IDeepCloneable {
+    private Dictionary<string, BinaryVector> BinaryParameters;
+    private Dictionary<string, IntegerVector> IntegerParameters;
+    private Dictionary<string, RealVector> RealParameters;
+    private Dictionary<string, Permutation> PermutationParameters;
 
     public ParameterVector(IEnumerable<KeyValuePair<string, BinaryVector>> binaryVectors = null,
@@ -42 +43 @@
       if (realVectors != null) RealParameters = realVectors.ToDictionary(x => x.Key, x => x.Value);
       if (permutations != null) PermutationParameters = permutations.ToDictionary(x => x.Key, x => x.Value);
+    }
+    private ParameterVector(ParameterVector original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      if (original.BinaryParameters != null) {
+        BinaryParameters = new Dictionary<string, BinaryVector>(original.BinaryParameters.Comparer);
+        foreach (var param in original.BinaryParameters)
+          BinaryParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.IntegerParameters != null) {
+        IntegerParameters = new Dictionary<string, IntegerVector>(original.IntegerParameters.Comparer);
+        foreach (var param in original.IntegerParameters)
+          IntegerParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.RealParameters != null) {
+        RealParameters = new Dictionary<string, RealVector>(original.RealParameters.Comparer);
+        foreach (var param in original.RealParameters)
+          RealParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.PermutationParameters != null) {
+        PermutationParameters = new Dictionary<string, Permutation>(original.PermutationParameters.Comparer);
+        foreach (var param in original.PermutationParameters)
+          PermutationParameters[param.Key] = cloner.Clone(param.Value);
+      }
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVector(this, cloner);
     }
 
@@ -53 +85 @@
 
     public IEnumerable<string> BinaryNames {
-      get { return BinaryParameters.Keys; }
+      get { return BinaryParameters != null ? BinaryParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -65 +97 @@
 
     public IEnumerable<string> IntegerNames {
-      get { return IntegerParameters.Keys; }
+      get { return IntegerParameters != null ? IntegerParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -77 +109 @@
 
     public IEnumerable<string> RealNames {
-      get { return RealParameters.Keys; }
+      get { return RealParameters != null ? RealParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -85 +117 @@
 
     public IEnumerable<string> PermutationNames {
-      get { return PermutationParameters.Keys; }
+      get { return PermutationParameters != null ? PermutationParameters.Keys : Enumerable.Empty<string>(); }
     }
   }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/RealParameterConfiguration.cs

@@ -71 +71 @@
       if (min.Count == 0) throw new ArgumentException("Bounds must be given for the real parameters.");
       if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
-      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
       this.length = new IntValue(length);
       bounds = new DoubleMatrix(min.Count, 2);

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj

@@ -121 +121 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="SimSharp, Version=3.0.3.0, Culture=neutral, PublicKeyToken=4222a9c6c8b27052, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\SimSharp.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -143 +138 @@
     <Compile Include="Datastructures\ParameterConfiguration.cs" />
     <Compile Include="Datastructures\ParameterVector.cs" />
+    <Compile Include="Interfaces\IParameterVectorMoveOperator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveProgrammableProblemEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorManipulator.cs" />
     <Compile Include="Operators\ParameterVectorCrossover.cs" />
+    <Compile Include="Operators\ParameterVectorMoveEvaluator.cs" />
+    <Compile Include="Operators\ParameterVectorMoveGenerator.cs" />
+    <Compile Include="Operators\ParameterVectorMoveMaker.cs" />
     <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorCreater.cs" />

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs

@@ -20 +20 @@
 #endregion
 
+using System.Collections.Generic;
 using HeuristicLab.Core;
 
@@ -26 +27 @@
     bool IsMaximizationProblem { get; }
     double Evaluate(IRandom random, ParameterVector vector);
+    IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector);
   }
 }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs

@@ -138 +138 @@
         UpdateMultiVectorEncodingOperators(solutionCreators, configuration);
       }
+      UpdateMoveOperators();
     }
 
@@ -597 +598 @@
     }
 
+    protected virtual void UpdateMoveOperators() {
+      Operators.RemoveAll(x => x is IParameterVectorMoveOperator);
+      var generator = new ParameterVectorMoveGenerator();
+      generator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      generator.ScriptParameter.ActualName = ScriptParameter.Name;
+
+      var evaluator = new ParameterVectorMoveEvaluator();
+      evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      evaluator.ScriptParameter.ActualName = ScriptParameter.Name;
+
+      var maker = new ParameterVectorMoveMaker();
+      maker.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      maker.MoveQualityParameter.ActualName = evaluator.MoveQualityParameter.ActualName;
+      maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+
+      Operators.AddRange(new IItem[] { generator, evaluator, maker });
+    }
+
     // ReSharper disable RedundantNameQualifier
     protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, Configuration config) {

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs

@@ -34 +34 @@
     protected SingleObjectiveScript(SingleObjectiveScript original, Cloner cloner)
       : base(original, cloner) { }
-    public SingleObjectiveScript() { }
+
+    public SingleObjectiveScript() {
+      Code = CodeTemplate;
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -78 +81 @@
   }
 
+  public IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector) {
+    // Create new vectors, based on the given one that represent small changes
+    // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
+    while (true) {
+      var neighbor = (ParameterVector)vector.Clone();
+      //e.g. make a bit flip in a binary parameter
+      //var bIndex = random.Next(neighbor.Binary(""b"").Length);
+      //neighbor.Binary(""b"")[bIndex] = !neighbor.Binary(""b"")[bIndex];
+      yield return neighbor;
+    }
+  }
+
   // implement further classes and methods
 }";