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

Timestamp:

05/15/14 15:06:57 (11 years ago)

Author:

abeham

Message:

#2174: Worked on programmable problem

• Changed ProblemBase to IProblemDefinition and SingleObjectiveProblemBase to ISingleObjectiveProblemDefinition
• Derived ParameterVectorCreater, -Crossover, and -Manipulator from MultiOperator<> instead of InstrumentedOperator
• Split the megamoth ScriptOnInstanceChanged to multiple methods dealing with single-vector and multi-vector encodings separately, it's still a lot of tedious code
• Removed maximization from Configuration again (would not be consistent with multi-objective problems)

Location:

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3

Files:

• Datastructures/BinaryParameterConfiguration.cs (modified) (1 diff)
• Datastructures/Configuration.cs (modified) (3 diffs)
• Datastructures/IntegerParameterConfiguration.cs (modified) (2 diffs)
• Datastructures/PermutationParameterConfiguration.cs (modified) (1 diff)
• Datastructures/RealParameterConfiguration.cs (modified) (2 diffs)
• HeuristicLab.Problems.Programmable-3.3.csproj (modified) (1 diff)
• Interfaces/IProblemDefinition.cs (moved) (moved from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/ProblemBase.cs) (1 diff)
• Interfaces/ISingleObjectiveProblemDefinition.cs (moved) (moved from branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemBase.cs) (1 diff)
• Operators/ParameterVectorCreater.cs (modified) (3 diffs)
• Operators/ParameterVectorCrossover.cs (modified) (3 diffs)
• Operators/ParameterVectorManipulator.cs (modified) (3 diffs)
• ProgrammableProblemScript.cs (modified) (2 diffs)
• SingleObjectiveProgrammableProblem.cs (modified) (10 diffs)
• SingleObjectiveScript.cs (modified) (2 diffs)

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

@@ -46 +46 @@
       length = cloner.Clone(original.length);
     }
-    public BinaryParameterConfiguration(int length)
-      : base() {
+    public BinaryParameterConfiguration(int length) {
       this.length = new IntValue(length);
     }

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

@@ -34 +34 @@
     public Dictionary<string, ParameterConfiguration> Parameters { get; protected set; }
 
-    [Storable]
-    public bool Maximization { get; protected set; }
-
     [StorableConstructor]
     protected Configuration(bool deserializing) : base(deserializing) { }
@@ -47 +44 @@
         }
       }
-      Maximization = original.Maximization;
     }
     public Configuration() {
@@ -88 +84 @@
     }
 
-    public Configuration AddPermutation(string name, PermutationTypes type, int length) {
+    public Configuration AddPermutation(string name, int length, PermutationTypes type) {
       if (Parameters.ContainsKey(name)) throw new ArgumentException("name must be unique", "name");
       Parameters.Add(name, new PermutationParameterConfiguration(length, type));
       return this;
     }
-
-    public Configuration SetMaximization(bool maximization) {
-      Maximization = maximization;
-      return this;
-    }
   }
 }

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

@@ -61 +61 @@
       bounds = cloner.Clone(original.bounds);
     }
-    public IntegerParameterConfiguration(int length, int min, int max, int? step = null)
-      : base() {
+    public IntegerParameterConfiguration(int length, int min, int max, int? step = null) {
       if (min >= max) throw new ArgumentException("min must be less than max", "min");
       if (step.HasValue && step.Value <= 0) throw new ArgumentException("step must be greater than zero or null", "step");
@@ -71 +70 @@
       if (step.HasValue) bounds[0, 2] = step.Value;
     }
-    public IntegerParameterConfiguration(int length, IList<int> min, IList<int> max, IList<int> step = null)
-      : base() {
+    public IntegerParameterConfiguration(int length, IList<int> min, IList<int> max, IList<int> step = null) {
       if (min.Count == 0) throw new ArgumentException("Bounds must be given for the integer parameters.");
       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, (m, M) => m >= M).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) 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/PermutationParameterConfiguration.cs

@@ -59 +59 @@
       type = cloner.Clone(original.type);
     }
-    public PermutationParameterConfiguration(int length, PermutationTypes type)
-      : base() {
+    public PermutationParameterConfiguration(int length, PermutationTypes type) {
       this.length = new IntValue(length);
       this.type = new PermutationType(type);

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

@@ -61 +61 @@
       bounds = cloner.Clone(original.bounds);
     }
-    public RealParameterConfiguration(int length, double min, double max)
-      : base() {
+    public RealParameterConfiguration(int length, double min, double max) {
       if (min >= max) throw new ArgumentException("min must be less than max", "min");
       this.length = new IntValue(length);
@@ -69 +68 @@
       bounds[0, 1] = max;
     }
-    public RealParameterConfiguration(int length, IList<double> min, IList<double> max)
-      : base() {
+    public RealParameterConfiguration(int length, IList<double> min, IList<double> max) {
       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, (m, M) => m >= M).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) 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

@@ -148 +148 @@
     <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorCreater.cs" />
-    <Compile Include="ProblemBase.cs" />
-    <Compile Include="SingleObjectiveProblemBase.cs" />
+    <Compile Include="Interfaces\IProblemDefinition.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveProblemDefinition.cs" />
     <Compile Include="ProgrammableProblemScript.cs" />
     <Compile Include="SingleObjectiveScript.cs" />

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

@@ -21 +21 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public abstract class ProblemBase {
-    public abstract Configuration GetConfiguration();
+  public interface IProblemDefinition {
+    Configuration GetConfiguration();
   }
 }

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

@@ -23 +23 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public abstract class SingleObjectiveProblemBase : ProblemBase {
-    public abstract double Evaluate(IRandom random, ParameterVector vector);
+  public interface ISingleObjectiveProblemDefinition : IProblemDefinition {
+    bool IsMaximizationProblem { get; }
+    double Evaluate(IRandom random, ParameterVector vector);
   }
 }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorCreater.cs

@@ -20 +20 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +30 @@
   [Item("ParameterVectorCreater", "Contains solution creators that together create a multi-vector encoding.")]
   [StorableClass]
-  public class ParameterVectorCreater : InstrumentedOperator, ISolutionCreator {
+  public class ParameterVectorCreater : MultiOperator<ISolutionCreator>, ISolutionCreator {
 
     [StorableConstructor]
@@ -39 +40 @@
       return new ParameterVectorCreater(this, cloner);
     }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
   }
 }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorCrossover.cs

@@ -20 +20 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +30 @@
   [Item("ParameterVector Crossover", "Applies different crossovers to cross a multi vector encoding.")]
   [StorableClass]
-  public class ParameterVectorCrossover : InstrumentedOperator, ICrossover {
+  public class ParameterVectorCrossover : MultiOperator<ICrossover>, ICrossover {
 
     [StorableConstructor]
@@ -41 +42 @@
       return new ParameterVectorCrossover(this, cloner);
     }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
   }
 }

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorManipulator.cs

@@ -20 +20 @@
 #endregion
 
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +30 @@
   [Item("ParameterVector Manipulator", "Applies different manipulators to change a multi vector encoding.")]
   [StorableClass]
-  public class ParameterVectorManipulator : InstrumentedOperator, IManipulator {
+  public class ParameterVectorManipulator : MultiOperator<IManipulator>, IManipulator {
 
     [StorableConstructor]
@@ -41 +42 @@
       return new ParameterVectorManipulator(this, cloner);
     }
+
+    public override IOperation InstrumentedApply() {
+      var baseOperations = base.InstrumentedApply();
+      return new OperationCollection(new[] { baseOperations }.Concat(Operators.Select(x => ExecutionContext.CreateOperation(x))));
+    }
   }
 }

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

@@ -40 +40 @@
     public ProgrammableProblemScript() { }
 
-    private volatile ProblemBase instance;
+    private volatile IProblemDefinition instance;
     private object locker = new object();
-    public ProblemBase Instance {
+    public IProblemDefinition Instance {
       get {
         SuppressEvents = true;
@@ -73 +73 @@
       var types = assembly.GetTypes();
       try {
-        Instance = (ProblemBase)Activator.CreateInstance(types.First(x => typeof(ProblemBase).IsAssignableFrom(x)));
+        Instance = (IProblemDefinition)Activator.CreateInstance(types.First(x => typeof(IProblemDefinition).IsAssignableFrom(x)));
       } catch {
         Instance = null;

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

@@ -45 +45 @@
 
     public static new Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Script; }
+      get { return Common.Resources.VSImageLibrary.Script; }
     }
 
@@ -76 +76 @@
     public SingleObjectiveProgrammableProblem()
       : base(new SingleObjectiveEvaluator(), new ParameterVectorCreater()) {
-      Parameters.Add(new ValueParameter<SingleObjectiveScript>("Script", "Defines the problem.", new SingleObjectiveScript() { Name = ItemName }));
+      Parameters.Add(new ValueParameter<SingleObjectiveScript>("Script", "Defines the problem.", new SingleObjectiveScript() { Name = Name }));
       Parameters.Add(new ValueParameter<Configuration>("Configuration", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));
 
@@ -93 +93 @@
 
     [StorableHook(HookType.AfterDeserialization)]
+    // ReSharper disable UnusedMember.Local
     private void AfterDeserialization() {
       RegisterEventHandlers();
     }
+    // ReSharper restore UnusedMember.Local
 
     private void RegisterEventHandlers() {
@@ -113 +115 @@
     private void ScriptOnNameChanged(object sender, EventArgs eventArgs) {
       if (sender != ScriptParameter.Value) return;
-      if (Name != ScriptParameter.Value.Name)
-        Name = ScriptParameter.Value.Name;
+      Name = ScriptParameter.Value.Name;
     }
 
     protected override void OnNameChanged() {
       base.OnNameChanged();
-      if (ScriptParameter.Value.Name != Name)
-        ScriptParameter.Value.Name = Name;
+      ScriptParameter.Value.Name = Name;
     }
 
     protected virtual void ScriptOnInstanceChanged(object sender, EventArgs eventArgs) {
-
       var instance = ScriptParameter.Value.Instance;
       if (instance == null) return;
@@ -130 +129 @@
       var configuration = instance.GetConfiguration();
       ConfigurationParameter.Value = configuration;
-      Maximization.Value = configuration.Maximization;
-
+      Maximization.Value = instance.IsMaximizationProblem;
+
+      var solutionCreators = UpdateDynamicConfigurationParameters(configuration);
+
+      if (solutionCreators.Count == 1) {
+        UpdateSingleVectorEncodingOperators(solutionCreators);
+      } else {
+        UpdateMultiVectorEncodingOperators(solutionCreators, configuration);
+      }
+    }
+
+    protected virtual List<ISolutionCreator> UpdateDynamicConfigurationParameters(Configuration configuration) {
       foreach (var param in DynamicConfigurationParameters)
         if (Parameters.Contains(param)) Parameters.Remove(param);
@@ -138 +147 @@
       var solutionCreators = new List<ISolutionCreator>();
       foreach (var param in configuration.Parameters) {
+        /*
+         * Binary Vectors
+         */
         var binConfig = param.Value as BinaryParameterConfiguration;
         if (binConfig != null) {
@@ -148 +160 @@
           solutionCreators.Add(creator);
         }
+        /*
+         * Integer Vectors
+         */
         var intConfig = param.Value as IntegerParameterConfiguration;
         if (intConfig != null) {
@@ -161 +176 @@
           solutionCreators.Add(creator);
         }
+        /*
+         * Real Vectors
+         */
         var realConfig = param.Value as RealParameterConfiguration;
         if (realConfig != null) {
@@ -174 +192 @@
           solutionCreators.Add(creator);
         }
+        /*
+         * Permutations
+         */
         var permConfig = param.Value as PermutationParameterConfiguration;
         if (permConfig != null) {
@@ -191 +212 @@
         Parameters.Add(param);
       }
-
-      // use specialized creators if the configuration consists only of a single parameter type
-      // this allows to use specialized algorithms such as CMA-ES
-      if (solutionCreators.Count == 1) { // single-vector encoding
+      return solutionCreators;
+    }
+
+    protected virtual void UpdateSingleVectorEncodingOperators(List<ISolutionCreator> solutionCreators) {
+      var newCreator = solutionCreators.Single();
+      var binCreator = newCreator as IBinaryVectorCreator;
+      if (binCreator != null) {
+        var paramName = binCreator.BinaryVectorParameter.ActualName;
+        // do not replace a binary vector creator that was manually set
+        if (!(SolutionCreator is IBinaryVectorCreator) || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != paramName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+        Operators.RemoveAll(x => x is ICrossover && !(x is IBinaryVectorCrossover) || x is IBinaryVectorCrossover && ((IBinaryVectorCrossover)x).ChildParameter.ActualName != paramName);
+        Operators.RemoveAll(x => x is IManipulator && !(x is IBinaryVectorManipulator) || x is IBinaryVectorManipulator && ((IBinaryVectorManipulator)x).BinaryVectorParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>().ToList();
+        var manipulators = ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>().ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+          xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+        }
+        foreach (var m in manipulators)
+          m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
+        Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+      }
+      var intCreator = newCreator as IIntegerVectorCreator;
+      if (intCreator != null) {
+        var paramName = intCreator.IntegerVectorParameter.ActualName;
+        // do not replace an integer vector creator that was manually set
+        if (!(SolutionCreator is IIntegerVectorCreator)
+          || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+        Operators.RemoveAll(x => x is ICrossover && !(x is IIntegerVectorCrossover) || x is IIntegerVectorCrossover && ((IIntegerVectorCrossover)x).ChildParameter.ActualName != paramName);
+        Operators.RemoveAll(x => x is IManipulator && !(x is IIntegerVectorManipulator) || x is IIntegerVectorManipulator && ((IIntegerVectorManipulator)x).IntegerVectorParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>().ToList();
+        var manipulators = ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+          xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+        }
+        foreach (var m in manipulators)
+          m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
+        foreach (var bo in crossovers.OfType<IBoundedIntegerVectorOperator>()
+              .Concat(manipulators.OfType<IBoundedIntegerVectorOperator>())
+              .ToList()) {
+          bo.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
+        }
+        Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+      }
+      var realCreator = newCreator as IRealVectorCreator;
+      if (realCreator != null) {
+        var paramName = realCreator.RealVectorParameter.ActualName;
+        // do not replace a real vector creator that was manually set
+        if (!(SolutionCreator is IRealVectorCreator)
+            || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+        Operators.RemoveAll(x => x is ICrossover && !(x is IRealVectorCrossover) || x is IRealVectorCrossover && ((IRealVectorCrossover)x).ChildParameter.ActualName != paramName);
+        Operators.RemoveAll(x => x is IManipulator && !(x is IRealVectorManipulator) || x is IRealVectorManipulator && ((IRealVectorManipulator)x).RealVectorParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IRealVectorCrossover>().ToList();
+        var manipulators = ApplicationManager.Manager.GetInstances<IRealVectorManipulator>().ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = realCreator.RealVectorParameter.ActualName;
+          xo.ParentsParameter.ActualName = realCreator.RealVectorParameter.ActualName;
+          xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+        }
+        foreach (var m in manipulators) {
+          m.RealVectorParameter.ActualName = realCreator.RealVectorParameter.ActualName;
+          m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
+        }
+        Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+      }
+      var permCreator = newCreator as IPermutationCreator;
+      if (permCreator != null) {
+        var paramName = permCreator.PermutationParameter.ActualName;
+        // do not replace a permutation creator that was manually set
+        if (!(SolutionCreator is IPermutationCreator)
+            || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
+          Operators.Remove(SolutionCreator);
+          SolutionCreator = newCreator;
+          Operators.Add(SolutionCreator);
+        }
+        Operators.RemoveAll(x => x is ICrossover && !(x is IPermutationCrossover) || x is IPermutationCrossover && ((IPermutationCrossover)x).ChildParameter.ActualName != paramName);
+        Operators.RemoveAll(x => x is IManipulator && !(x is IPermutationManipulator) || x is IPermutationManipulator && ((IPermutationManipulator)x).PermutationParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IPermutationCrossover>().ToList();
+        var manipulators = ApplicationManager.Manager.GetInstances<IPermutationManipulator>().ToList();
+        foreach (var xo in crossovers) {
+          xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
+          xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
+        }
+        foreach (var m in manipulators)
+          m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
+        Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+      }
+    }
+
+    protected virtual void UpdateMultiVectorEncodingOperators(List<ISolutionCreator> solutionCreators, Configuration configuration) {
+      var oldCreator = SolutionCreator as ParameterVectorCreater;
+      var newCreator = new ParameterVectorCreater();
+
+      /*
+       * Binary Vectors
+       */
+      var newBinParams = new HashSet<string>(solutionCreators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+      if (oldCreator != null) {
+        // we want to reuse the old creator
+        var oldParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>()
+          .Select(x => x.BinaryVectorParameter.ActualName));
+        foreach (var toAdd in newBinParams.Except(oldParams)) {
+          var paramName = toAdd;
+          oldCreator.Operators.Add(
+            solutionCreators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == paramName));
+        }
+        foreach (var toRemove in oldParams.Except(newBinParams)) {
+          var paramName = toRemove;
+          var op =
+            oldCreator.Operators.OfType<IBinaryVectorCreator>()
+              .SingleOrDefault(x => x.BinaryVectorParameter.ActualName == paramName);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+      } else {
+        // we will use the new creator
+        foreach (var binCreator in solutionCreators.OfType<IBinaryVectorCreator>()) {
+          newCreator.Operators.Add(binCreator);
+        }
+      }
+
+      /*
+       * Integer Vectors
+       */
+      var newIntParams = new HashSet<string>(solutionCreators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+      if (oldCreator != null) {
+        // we want to reuse the old creator
+        var oldParams = new HashSet<string>(oldCreator
+          .Operators.OfType<IIntegerVectorCreator>()
+          .Select(x => x.IntegerVectorParameter.ActualName));
+        foreach (var toAdd in newIntParams.Except(oldParams)) {
+          var paramName = toAdd;
+          oldCreator.Operators.Add(
+            solutionCreators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == paramName));
+        }
+        foreach (var toRemove in oldParams.Except(newIntParams)) {
+          var paramName = toRemove;
+          var op =
+            oldCreator.Operators.OfType<IIntegerVectorCreator>()
+              .SingleOrDefault(x => x.IntegerVectorParameter.ActualName == paramName);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+      } else {
+        // we will use the new creator
+        foreach (var intCreator in solutionCreators.OfType<IIntegerVectorCreator>()) {
+          newCreator.Operators.Add(intCreator);
+        }
+      }
+
+      /*
+       * Real Vectors
+       */
+      var newRealParams = new HashSet<string>(solutionCreators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+      if (oldCreator != null) {
+        // we want to reuse the old creator
+        var oldParams = new HashSet<string>(oldCreator
+          .Operators.OfType<IRealVectorCreator>()
+          .Select(x => x.RealVectorParameter.ActualName));
+        foreach (var toAdd in newRealParams.Except(oldParams)) {
+          var paramName = toAdd;
+          oldCreator.Operators.Add(
+            solutionCreators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == paramName));
+        }
+        foreach (var toRemove in oldParams.Except(newRealParams)) {
+          var paramName = toRemove;
+          var op =
+            oldCreator.Operators.OfType<IRealVectorCreator>()
+              .SingleOrDefault(x => x.RealVectorParameter.ActualName == paramName);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+      } else {
+        // we will use the new creator
+        foreach (var realCreator in solutionCreators.OfType<IRealVectorCreator>()) {
+          newCreator.Operators.Add(realCreator);
+        }
+      }
+
+      /*
+       * Permutations
+       */
+      var newPermParams = new HashSet<string>(solutionCreators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+      if (oldCreator != null) {
+        // we want to reuse the old creator
+        var oldParams = new HashSet<string>(oldCreator
+          .Operators.OfType<IPermutationCreator>()
+          .Select(x => x.PermutationParameter.ActualName));
+        foreach (var toAdd in newPermParams.Except(oldParams)) {
+          var paramName = toAdd;
+          oldCreator.Operators.Add(
+            solutionCreators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == paramName));
+        }
+        foreach (var toRemove in oldParams.Except(newPermParams)) {
+          var paramName = toRemove;
+          var op =
+            oldCreator.Operators.OfType<IPermutationCreator>()
+              .SingleOrDefault(x => x.PermutationParameter.ActualName == paramName);
+          if (op != null) oldCreator.Operators.Remove(op);
+        }
+        // we also have to sync the permutation type (in case this changes, as it is a value parameter)
+        foreach (var intersect in newPermParams.Intersect(oldParams)) {
+          var paramName = intersect;
+          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>()
+            .Single(x => x.PermutationParameter.ActualName == paramName);
+          var newPermCreator = solutionCreators.OfType<IPermutationCreator>()
+            .Single(x => x.PermutationParameter.ActualName == paramName);
+          oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
+        }
+      } else {
+        // we will use the new creator
+        foreach (var permCreator in solutionCreators.OfType<IPermutationCreator>()) {
+          newCreator.Operators.Add(permCreator);
+        }
+      }
+
+      if (oldCreator == null) SolutionCreator = newCreator;
+
+      // crossover and manipulator for multi-vector encoding
+      // the condition checks if a multi-vector encoding is to be updated (there already exists ParameterVectorCrossover and ParameterVectorManipulator)
+      if (Operators.OfType<ParameterVectorCrossover>().Any() && Operators.OfType<ParameterVectorManipulator>().Any()) {
+        // Update the crossovers
+        foreach (var oldXo in Operators.OfType<ParameterVectorCrossover>()) {
+          /*
+           * Binary Vectors
+           */
+          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, configuration));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+
+          /*
+           * Integer Vectors
+           */
+          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, configuration));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldXo.Operators.OfType<IIntegerVectorCrossover>()
+                .SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+
+          /*
+           * Real Vectors
+           */
+          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, configuration));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+
+          /*
+           * Permutations
+           */
+          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, configuration));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            if (op != null) oldXo.Operators.Remove(op);
+          }
+        }
+        // Update the manipulators
+        foreach (var oldM in Operators.OfType<ParameterVectorManipulator>()) {
+          /*
+           * Binary Vectors
+           */
+          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>()
+            .Select(x => x.BinaryVectorParameter.ActualName));
+          foreach (var toAdd in newBinParams.Except(oldBinParams))
+            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, configuration));
+          foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldM.Operators.OfType<IBinaryVectorManipulator>()
+                .SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+
+          /*
+           * Integer Vectors
+           */
+          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>()
+            .Select(x => x.IntegerVectorParameter.ActualName));
+          foreach (var toAdd in newIntParams.Except(oldIntParams))
+            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, configuration));
+          foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldM.Operators.OfType<IIntegerVectorManipulator>()
+                .SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+
+          /*
+           * Real Vectors
+           */
+          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>()
+            .Select(x => x.RealVectorParameter.ActualName));
+          foreach (var toAdd in newRealParams.Except(oldRealParams))
+            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, configuration));
+          foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldM.Operators.OfType<IRealVectorManipulator>()
+                .SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+
+          /*
+           * Permutations
+           */
+          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>()
+            .Select(x => x.PermutationParameter.ActualName));
+          foreach (var toAdd in newPermParams.Except(oldPermParams))
+            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, configuration));
+          foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldM.Operators.OfType<IPermutationManipulator>()
+                .SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+            if (op != null) oldM.Operators.Remove(op);
+          }
+        }
+      } else {
+        // change from single-vector encoding to multi-vector encoding
         Operators.RemoveAll(x => x is ICrossover);
         Operators.RemoveAll(x => x is IManipulator);
-        var newCreator = solutionCreators.Single();
-        var binCreator = newCreator as IBinaryVectorCreator;
-        if (binCreator != null) {
-          // do not replace a binary vector creator that was manually set
-          if (!(SolutionCreator is IBinaryVectorCreator)
-              || ((IBinaryVectorCreator)SolutionCreator).BinaryVectorParameter.ActualName != binCreator.BinaryVectorParameter.ActualName) {
-            Operators.Remove(SolutionCreator);
-            SolutionCreator = newCreator;
-            Operators.Add(SolutionCreator);
-          }
-          var crossovers = ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>().ToList();
-          var manipulators = ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>().ToList();
-          foreach (var xo in crossovers) {
-            xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
-            xo.ParentsParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
-          }
-          foreach (var m in manipulators)
-            m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
-          Operators.AddRange(crossovers);
-          Operators.AddRange(manipulators);
-        }
-        var intCreator = newCreator as IIntegerVectorCreator;
-        if (intCreator != null) {
-          // do not replace an integer vector creator that was manually set
-          if (!(SolutionCreator is IIntegerVectorCreator)
-              || ((IIntegerVectorCreator)SolutionCreator).IntegerVectorParameter.ActualName != intCreator.IntegerVectorParameter.ActualName) {
-            Operators.Remove(SolutionCreator);
-            SolutionCreator = newCreator;
-            Operators.Add(SolutionCreator);
-          }
-          var crossovers = ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>().ToList();
-          var manipulators = ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().ToList();
-          foreach (var xo in crossovers) {
-            xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
-            xo.ParentsParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
-          }
-          foreach (var m in manipulators)
-            m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
-          foreach (var bo in crossovers.OfType<IBoundedIntegerVectorOperator>().Concat(manipulators.OfType<IBoundedIntegerVectorOperator>()).ToList()) {
-            bo.BoundsParameter.ActualName = intCreator.BoundsParameter.ActualName;
-          }
-          Operators.AddRange(crossovers);
-          Operators.AddRange(manipulators);
-        }
-        var realCreator = newCreator as IRealVectorCreator;
-        if (realCreator != null) {
-          // do not replace a real vector creator that was manually set
-          if (!(SolutionCreator is IRealVectorCreator)
-              || ((IRealVectorCreator)SolutionCreator).RealVectorParameter.ActualName != realCreator.RealVectorParameter.ActualName) {
-            Operators.Remove(SolutionCreator);
-            SolutionCreator = newCreator;
-            Operators.Add(SolutionCreator);
-          }
-          var crossovers = ApplicationManager.Manager.GetInstances<IRealVectorCrossover>().ToList();
-          var manipulators = ApplicationManager.Manager.GetInstances<IRealVectorManipulator>().ToList();
-          foreach (var xo in crossovers) {
-            xo.ChildParameter.ActualName = realCreator.RealVectorParameter.ActualName;
-            xo.ParentsParameter.ActualName = realCreator.RealVectorParameter.ActualName;
-            xo.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          }
-          foreach (var m in manipulators) {
-            m.RealVectorParameter.ActualName = realCreator.RealVectorParameter.ActualName;
-            m.BoundsParameter.ActualName = realCreator.BoundsParameter.ActualName;
-          }
-          Operators.AddRange(crossovers);
-          Operators.AddRange(manipulators);
-        }
-        var permCreator = newCreator as IPermutationCreator;
-        if (permCreator != null) {
-          // do not replace a permutation creator that was manually set
-          if (!(SolutionCreator is IPermutationCreator)
-              || ((IPermutationCreator)SolutionCreator).PermutationParameter.ActualName != permCreator.PermutationParameter.ActualName) {
-            Operators.Remove(SolutionCreator);
-            SolutionCreator = newCreator;
-            Operators.Add(SolutionCreator);
-          }
-          var crossovers = ApplicationManager.Manager.GetInstances<IPermutationCrossover>().ToList();
-          var manipulators = ApplicationManager.Manager.GetInstances<IPermutationManipulator>().ToList();
-          foreach (var xo in crossovers) {
-            xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
-            xo.ParentsParameter.ActualName = permCreator.PermutationParameter.ActualName;
-          }
-          foreach (var m in manipulators)
-            m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
-          Operators.AddRange(crossovers);
-          Operators.AddRange(manipulators);
-        }
-      } else { // multi-vector encoding
-        var oldCreator = SolutionCreator as ParameterVectorCreater;
-        var newCreator = new ParameterVectorCreater();
-        var newBinParams = new HashSet<string>(solutionCreators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
-        if (oldCreator != null) { // we want to reuse the old creator
-          var oldParams = new HashSet<string>(oldCreator
-            .BeforeExecutionOperators.OfType<IBinaryVectorCreator>()
-            .Select(x => x.BinaryVectorParameter.ActualName));
-          foreach (var toAdd in newBinParams.Except(oldParams)) {
-            var paramName = toAdd;
-            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == paramName));
-          }
-          foreach (var toRemove in oldParams.Except(newBinParams)) {
-            var paramName = toRemove;
-            oldCreator.BeforeExecutionOperators.RemoveAll(
-              op => op is IBinaryVectorCreator && ((IBinaryVectorCreator)op).BinaryVectorParameter.ActualName == paramName);
-          }
-        } else { // we will use the new creator
-          foreach (var binCreator in solutionCreators.OfType<IBinaryVectorCreator>()) {
-            newCreator.BeforeExecutionOperators.Add(binCreator);
-          }
-        }
-
-        var newIntParams = new HashSet<string>(solutionCreators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
-        if (oldCreator != null) { // we want to reuse the old creator
-          var oldParams = new HashSet<string>(oldCreator
-            .BeforeExecutionOperators.OfType<IIntegerVectorCreator>()
-            .Select(x => x.IntegerVectorParameter.ActualName));
-          foreach (var toAdd in newIntParams.Except(oldParams)) {
-            var paramName = toAdd;
-            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == paramName));
-          }
-          foreach (var toRemove in oldParams.Except(newIntParams)) {
-            var paramName = toRemove;
-            oldCreator.BeforeExecutionOperators.RemoveAll(
-              op => op is IIntegerVectorCreator && ((IIntegerVectorCreator)op).IntegerVectorParameter.ActualName == paramName);
-          }
-        } else { // we will use the new creator
-          foreach (var intCreator in solutionCreators.OfType<IIntegerVectorCreator>()) {
-            newCreator.BeforeExecutionOperators.Add(intCreator);
-          }
-        }
-
-        var newRealParams = new HashSet<string>(solutionCreators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
-        if (oldCreator != null) { // we want to reuse the old creator
-          var oldParams = new HashSet<string>(oldCreator
-            .BeforeExecutionOperators.OfType<IRealVectorCreator>()
-            .Select(x => x.RealVectorParameter.ActualName));
-          foreach (var toAdd in newRealParams.Except(oldParams)) {
-            var paramName = toAdd;
-            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == paramName));
-          }
-          foreach (var toRemove in oldParams.Except(newRealParams)) {
-            var paramName = toRemove;
-            oldCreator.BeforeExecutionOperators.RemoveAll(
-              op => op is IRealVectorCreator && ((IRealVectorCreator)op).RealVectorParameter.ActualName == paramName);
-          }
-        } else { // we will use the new creator
-          foreach (var realCreator in solutionCreators.OfType<IRealVectorCreator>()) {
-            newCreator.BeforeExecutionOperators.Add(realCreator);
-          }
-        }
-
-        var newPermParams = new HashSet<string>(solutionCreators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
-        if (oldCreator != null) { // we want to reuse the old creator
-          var oldParams = new HashSet<string>(oldCreator
-            .BeforeExecutionOperators.OfType<IPermutationCreator>()
-            .Select(x => x.PermutationParameter.ActualName));
-          foreach (var toAdd in newPermParams.Except(oldParams)) {
-            var paramName = toAdd;
-            oldCreator.BeforeExecutionOperators.Add(solutionCreators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == paramName));
-          }
-          foreach (var toRemove in oldParams.Except(newPermParams)) {
-            var paramName = toRemove;
-            oldCreator.BeforeExecutionOperators.RemoveAll(
-              op => op is IPermutationCreator && ((IPermutationCreator)op).PermutationParameter.ActualName == paramName);
-          }
-          // we also have to sync the permutation type (in case this changes, as it is a value parameter)
-          foreach (var intersect in newPermParams.Intersect(oldParams)) {
-            var paramName = intersect;
-            var oldPermCreator = oldCreator.BeforeExecutionOperators.OfType<IPermutationCreator>()
-              .Single(x => x.PermutationParameter.ActualName == paramName);
-            var newPermCreator = solutionCreators.OfType<IPermutationCreator>()
-                .Single(x => x.PermutationParameter.ActualName == paramName);
-            oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
-          }
-        } else { // we will use the new creator
-          foreach (var permCreator in solutionCreators.OfType<IPermutationCreator>()) {
-            newCreator.BeforeExecutionOperators.Add(permCreator);
-          }
-        }
-
-        // 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);
-        }
-      }
-    }
+        var crossover = new ParameterVectorCrossover();
+        var manipulator = new ParameterVectorManipulator();
+        foreach (var param in configuration.Parameters) {
+          if (param.Value is BinaryParameterConfiguration) {
+            crossover.Operators.Add(GetDefaultBinaryCrossover(param.Key, configuration));
+            manipulator.Operators.Add(GetDefaultBinaryManipulator(param.Key, configuration));
+            continue;
+          }
+          var intConfig = param.Value as IntegerParameterConfiguration;
+          if (intConfig != null) {
+            crossover.Operators.Add(GetDefaultIntegerCrossover(param.Key, configuration));
+            manipulator.Operators.Add(GetDefaultIntegerManipulator(param.Key, configuration));
+            continue;
+          }
+          var realConfig = param.Value as RealParameterConfiguration;
+          if (realConfig != null) {
+            crossover.Operators.Add(GetDefaultRealCrossover(param.Key, configuration));
+            manipulator.Operators.Add(GetDefaultRealManipulator(param.Key, configuration));
+            continue;
+          }
+          var permConfig = param.Value as PermutationParameterConfiguration;
+          if (permConfig != null) {
+            crossover.Operators.Add(GetDefaultPermutationCrossover(param.Key, configuration));
+            manipulator.Operators.Add(GetDefaultPermutationManipulator(param.Key, configuration));
+            continue;
+          }
+          throw new InvalidOperationException("Unknown type for parameter " + param.Key);
+        }
+        Operators.Add(crossover);
+        Operators.Add(manipulator);
+      }
+    }
+
+    // ReSharper disable RedundantNameQualifier
+    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, Configuration config) {
+      var binConfig = (BinaryParameterConfiguration)config.Parameters[paramName];
+      IBinaryVectorCrossover binXo;
+      if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
+      else binXo = new Encodings.BinaryVectorEncoding.UniformCrossover();
+      binXo.ChildParameter.ActualName = paramName;
+      binXo.ParentsParameter.ActualName = paramName;
+      return binXo;
+    }
+
+    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, Configuration config) {
+      var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
+      binM.BinaryVectorParameter.ActualName = paramName;
+      binM.MutationProbabilityParameter.Value = new DoubleValue(0.1);
+      return binM;
+    }
+
+    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, Configuration config) {
+      var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaBetaCrossover();
+      intXo.ChildParameter.ActualName = paramName;
+      intXo.ParentsParameter.ActualName = paramName;
+      intXo.BoundsParameter.ActualName = paramName + "Bounds";
+      intXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      intXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      return intXo;
+    }
+
+    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, Configuration configuration) {
+      var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
+      intM.IntegerVectorParameter.ActualName = paramName;
+      intM.BoundsParameter.ActualName = paramName + "Bounds";
+      intM.ProbabilityParameter.Value = new DoubleValue(0.1);
+      return intM;
+    }
+
+    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, Configuration configuration) {
+      var realXo = new Encodings.RealVectorEncoding.BlendAlphaBetaCrossover();
+      realXo.ChildParameter.ActualName = paramName;
+      realXo.ParentsParameter.ActualName = paramName;
+      realXo.BoundsParameter.ActualName = paramName + "Bounds";
+      realXo.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      realXo.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      return realXo;
+    }
+
+    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, Configuration configuration) {
+      var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
+      realM.RealVectorParameter.ActualName = paramName;
+      realM.BoundsParameter.ActualName = paramName + "Bounds";
+      return realM;
+    }
+
+    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, Configuration configuration) {
+      var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
+      permXo.ChildParameter.ActualName = paramName;
+      permXo.ParentsParameter.ActualName = paramName;
+      return permXo;
+    }
+
+    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, Configuration configuration) {
+      var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
+      permM.PermutationParameter.ActualName = paramName;
+      return permM;
+    }
+    // ReSharper restore RedundantNameQualifier
   }
 }

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

@@ -40 +40 @@
     }
 
-    public new SingleObjectiveProblemBase Instance {
-      get { return (SingleObjectiveProblemBase)base.Instance; }
+    public new ISingleObjectiveProblemDefinition Instance {
+      get { return (ISingleObjectiveProblemDefinition)base.Instance; }
       protected set { base.Instance = value; }
     }
@@ -56 +56 @@
 using HeuristicLab.Problems.Programmable;
 
-public class MyProblem : HeuristicLab.Problems.Programmable.SingleObjectiveProblemBase {
-  public MyProblem() {
+public class ProblemDefinition : ISingleObjectiveProblemDefinition {
+  public ProblemDefinition() {
     // initialize private fields
   }
 
-  public override Configuration GetConfiguration() {
+  public bool IsMaximizationProblem { get { return false; } }
+
+  public Configuration GetConfiguration() {
     return new Configuration()
-      // .SetMaximization(true)
-      // add an arbitrary number of uniquely named parameter vectors
-      // .AddBinary(""p"", length: 5)
+      // .AddBinary(""b"", length: 5)
       // .AddInteger(""i"", length: 5, min: 2, max: 14, step: 4)
       // .AddReal(""r"", length: 5, min: -1.0, max: 1.0)
-      // .AddPermutation(""P"", type: PermutationTypes.Absolute, length: 5)
+      // .AddPermutation(""P"", length: 5, type: PermutationTypes.Absolute)
     ;
   }
 
-  public override double Evaluate(IRandom random, ParameterVector vector) {
+  public double Evaluate(IRandom random, ParameterVector vector) {
     var quality = 0.0;
     // quality = vector.Real(""r"").Select(x => x * x).Sum();