Changeset 10855 for branches/SimSharp/HeuristicLab.Problems.Programmable

Timestamp:

05/14/14 15:58:48 (11 years ago)

Author:

abeham

Message:

#2174: Added crossover and manipulator for multi-vector encoding

Location:

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3

Files:

• Datastructures/Configuration.cs (modified) (1 diff)
• SingleObjectiveProgrammableProblem.cs (modified) (2 diffs)

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

@@ -58 +58 @@
 
 
-    public Configuration AddBoolean(string name, int length) {
+    public Configuration AddBinary(string name, int length) {
       if (Parameters.ContainsKey(name)) throw new ArgumentException("name must be unique", "name");
       Parameters.Add(name, new BinaryParameterConfiguration(length));

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

@@ -137 +137 @@
 
       var solutionCreators = new List<ISolutionCreator>();
-      foreach (var parameters in configuration.Parameters) {
-        var binConfig = parameters.Value as BinaryParameterConfiguration;
+      foreach (var param in configuration.Parameters) {
+        var binConfig = param.Value as BinaryParameterConfiguration;
         if (binConfig != null) {
-          var p = new ValueParameter<IntValue>(parameters.Key + "Length", binConfig.Length);
+          var p = new ValueParameter<IntValue>(param.Key + "Length", binConfig.Length);
           DynamicConfigurationParameters.Add(p);
 
           var creator = new RandomBinaryVectorCreator();
-          creator.BinaryVectorParameter.ActualName = parameters.Key;
+          creator.BinaryVectorParameter.ActualName = param.Key;
           creator.LengthParameter.ActualName = p.Name;
           solutionCreators.Add(creator);
         }
-        var intConfig = parameters.Value as IntegerParameterConfiguration;
+        var intConfig = param.Value as IntegerParameterConfiguration;
         if (intConfig != null) {
-          var l = new ValueParameter<IntValue>(parameters.Key + "Length", intConfig.Length);
-          var b = new ValueParameter<IntMatrix>(parameters.Key + "Bounds", intConfig.Bounds);
+          var l = new ValueParameter<IntValue>(param.Key + "Length", intConfig.Length);
+          var b = new ValueParameter<IntMatrix>(param.Key + "Bounds", intConfig.Bounds);
           DynamicConfigurationParameters.Add(l);
           DynamicConfigurationParameters.Add(b);
 
           var creator = new UniformRandomIntegerVectorCreator();
-          creator.IntegerVectorParameter.ActualName = parameters.Key;
+          creator.IntegerVectorParameter.ActualName = param.Key;
           creator.LengthParameter.ActualName = l.Name;
           creator.BoundsParameter.ActualName = b.Name;
           solutionCreators.Add(creator);
         }
-        var realConfig = parameters.Value as RealParameterConfiguration;
+        var realConfig = param.Value as RealParameterConfiguration;
         if (realConfig != null) {
-          var l = new ValueParameter<IntValue>(parameters.Key + "Length", realConfig.Length);
-          var b = new ValueParameter<DoubleMatrix>(parameters.Key + "Bounds", realConfig.Bounds);
+          var l = new ValueParameter<IntValue>(param.Key + "Length", realConfig.Length);
+          var b = new ValueParameter<DoubleMatrix>(param.Key + "Bounds", realConfig.Bounds);
           DynamicConfigurationParameters.Add(l);
           DynamicConfigurationParameters.Add(b);
 
           var creator = new UniformRandomRealVectorCreator();
-          creator.RealVectorParameter.ActualName = parameters.Key;
+          creator.RealVectorParameter.ActualName = param.Key;
           creator.LengthParameter.ActualName = l.Name;
           creator.BoundsParameter.ActualName = b.Name;
           solutionCreators.Add(creator);
         }
-        var permConfig = parameters.Value as PermutationParameterConfiguration;
+        var permConfig = param.Value as PermutationParameterConfiguration;
         if (permConfig != null) {
-          var l = new ValueParameter<IntValue>(parameters.Key + "Length", permConfig.Length);
+          var l = new ValueParameter<IntValue>(param.Key + "Length", permConfig.Length);
           DynamicConfigurationParameters.Add(l);
 
           var creator = new RandomPermutationCreator();
-          creator.PermutationParameter.ActualName = parameters.Key;
+          creator.PermutationParameter.ActualName = param.Key;
           creator.LengthParameter.ActualName = l.Name;
           creator.PermutationTypeParameter.Value = permConfig.Type;
@@ -375 +375 @@
           }
         }
+
+        // crossover and manipulator for multi-vector encoding
+        if (Operators.OfType<ParameterVectorCrossover>().Any()) {
+          foreach (var oldXo in Operators.OfType<ParameterVectorCrossover>()) {
+            // TODO: compare crossovers for old configuration with new configuration
+          }
+          foreach (var oldM in Operators.OfType<ParameterVectorManipulator>()) {
+            // TODO: compare manipulators for old configuration with new configuration
+          }
+        } else {
+          Operators.RemoveAll(x => x is ICrossover);
+          Operators.RemoveAll(x => x is IManipulator);
+          var crossover = new ParameterVectorCrossover();
+          var manipulator = new ParameterVectorManipulator();
+          foreach (var param in configuration.Parameters) {
+            var binConfig = param.Value as BinaryParameterConfiguration;
+            if (binConfig != null) {
+              IBinaryVectorCrossover binXo;
+              if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
+              else binXo = new Encodings.BinaryVectorEncoding.UniformCrossover();
+              binXo.ChildParameter.ActualName = param.Key;
+              binXo.ParentsParameter.ActualName = param.Key;
+              var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
+              binM.BinaryVectorParameter.ActualName = param.Key;
+              binM.MutationProbabilityParameter.Value = new DoubleValue(0.1);
+              crossover.BeforeExecutionOperators.Add(binXo);
+              manipulator.BeforeExecutionOperators.Add(binM);
+              continue;
+            }
+            var intConfig = param.Value as IntegerParameterConfiguration;
+            if (intConfig != null) {
+              var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaBetaCrossover();
+              intXo.ChildParameter.ActualName = param.Key;
+              intXo.ParentsParameter.ActualName = param.Key;
+              intXo.BoundsParameter.ActualName = param.Key + "Bounds";
+              intXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+              intXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+              var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
+              intM.IntegerVectorParameter.ActualName = param.Key;
+              intM.BoundsParameter.ActualName = param.Key + "Bounds";
+              intM.ProbabilityParameter.Value = new DoubleValue(0.1);
+              crossover.BeforeExecutionOperators.Add(intXo);
+              manipulator.BeforeExecutionOperators.Add(intM);
+              continue;
+            }
+            var realConfig = param.Value as RealParameterConfiguration;
+            if (realConfig != null) {
+              var realXo = new Encodings.RealVectorEncoding.BlendAlphaBetaCrossover();
+              realXo.ChildParameter.ActualName = param.Key;
+              realXo.ParentsParameter.ActualName = param.Key;
+              realXo.BoundsParameter.ActualName = param.Key + "Bounds";
+              realXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+              realXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+              var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
+              realM.RealVectorParameter.ActualName = param.Key;
+              realM.BoundsParameter.ActualName = param.Key + "Bounds";
+              crossover.BeforeExecutionOperators.Add(realXo);
+              manipulator.BeforeExecutionOperators.Add(realM);
+              continue;
+            }
+            var permConfig = param.Value as PermutationParameterConfiguration;
+            if (permConfig != null) {
+              var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
+              permXo.ChildParameter.ActualName = param.Key;
+              permXo.ParentsParameter.ActualName = param.Key;
+              var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
+              permM.PermutationParameter.ActualName = param.Key;
+              crossover.BeforeExecutionOperators.Add(permXo);
+              manipulator.BeforeExecutionOperators.Add(permM);
+              continue;
+            }
+            throw new InvalidOperationException("Unknown type for parameter " + param.Key);
+          }
+          Operators.Add(crossover);
+          Operators.Add(manipulator);
+        }
       }
     }