Changeset 11484 for branches

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.cs

-                      r11397
+                      r11484
 namespace HeuristicLab.Problems.Programmable.Views {
   [View("ProblemDefinitionScriptView")]
   [Content(typeof(ProblemDefinitionScript), IsDefaultView = true)]
+  [Content(typeof(ProblemScript), IsDefaultView = true)]
   public partial class ProblemDefinitionScriptView : ScriptView {
     public new ProblemDefinitionScript Content {
       get { return (ProblemDefinitionScript)base.Content; }
+    public new ProblemScript Content {
+      get { return (ProblemScript)base.Content; }
       set { base.Content = value; }
+    }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Helper.cs

-                      r11405
+                      r11484
 namespace HeuristicLab.Problems.Programmable {
   internal static class Helper {
+    internal static ParameterVector Extract(IScope scope, Configuration config) {
+      var binDict = new Dictionary<string, BinaryVector>();
+      var intDict = new Dictionary<string, IntegerVector>();
+      var realDict = new Dictionary<string, RealVector>();
+      var permDict = new Dictionary<string, Permutation>();
+      foreach (var param in config.Parameters) {
+        var binConfig = param.Value as BinaryParameterConfiguration;
+        if (binConfig != null) {
+          binDict.Add(param.Key, (BinaryVector)scope.Variables[param.Key].Value);
+          continue;
+    internal static Individual Extract(IScope scope, Encoding encoding) {
+      Dictionary<string, BinaryVector> binDict = null;
+      Dictionary<string, IntegerVector> intDict = null;
+      Dictionary<string, RealVector> realDict = null;
+      Dictionary<string, Permutation> permDict = null;
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        foreach (var enc in multiEncoding.Encodings) {
+          var binConfig = enc as BinaryEncoding;
+          if (binConfig != null) {
+            if (binDict == null) binDict = new Dictionary<string, BinaryVector>();
+            binDict.Add(enc.Name, (BinaryVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var intConfig = enc as IntegerEncoding;
+          if (intConfig != null) {
+            if (intDict == null) intDict = new Dictionary<string, IntegerVector>();
+            intDict.Add(enc.Name, (IntegerVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var realConfig = enc as RealEncoding;
+          if (realConfig != null) {
+            if (realDict == null) realDict = new Dictionary<string, RealVector>();
+            realDict.Add(enc.Name, (RealVector)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          var permConfig = enc as PermutationEncoding;
+          if (permConfig != null) {
+            if (permDict == null) permDict = new Dictionary<string, Permutation>();
+            permDict.Add(enc.Name, (Permutation)scope.Variables[enc.Name].Value);
+            continue;
+          }
+          throw new InvalidOperationException("Encoding for variable " + enc.Name + " not recognized.");
+        }
+        var intConfig = param.Value as IntegerParameterConfiguration;
+        if (intConfig != null) {
+          intDict.Add(param.Key, (IntegerVector)scope.Variables[param.Key].Value);
+          continue;
+        }
+        var realConfig = param.Value as RealParameterConfiguration;
+        if (realConfig != null) {
+          realDict.Add(param.Key, (RealVector)scope.Variables[param.Key].Value);
+          continue;
+        }
+        var permConfig = param.Value as PermutationParameterConfiguration;
+        if (permConfig != null) {
+          permDict.Add(param.Key, (Permutation)scope.Variables[param.Key].Value);
+          continue;
+        }
+        throw new InvalidOperationException("Parameter " + param.Key + " not found.");
+      } else {
+        var binaryEncoding = encoding as BinaryEncoding;
+        var handled = binaryEncoding != null;
+        if (binaryEncoding != null) binDict = new Dictionary<string, BinaryVector>(capacity: 1) {
+            {binaryEncoding.Name, (BinaryVector)scope.Variables[binaryEncoding.Name].Value}
+          };
+        var integerEncoding = encoding as IntegerEncoding;
+        handled = handled || integerEncoding != null;
+        if (integerEncoding != null) intDict = new Dictionary<string, IntegerVector>(capacity: 1) {
+            {integerEncoding.Name, (IntegerVector)scope.Variables[integerEncoding.Name].Value}
+          };
+        var realEncoding = encoding as RealEncoding;
+        handled = handled || realEncoding != null;
+        if (realEncoding != null) realDict = new Dictionary<string, RealVector>(capacity: 1) {
+            {realEncoding.Name, (RealVector)scope.Variables[realEncoding.Name].Value}
+          };
+        var permEncoding = encoding as PermutationEncoding;
+        handled = handled || permEncoding != null;
+        if (permEncoding != null) permDict = new Dictionary<string, Permutation>(capacity: 1) {
+            {permEncoding.ItemName, (Permutation)scope.Variables[permEncoding.ItemName].Value}
+          };
+        if (!handled) throw new InvalidOperationException("Encoding for variable " + encoding.Name + " not recognized.");
+      }
+      return new ParameterVector(
+        binaryVectors: binDict.Count > 0 ? binDict : null,
+        integerVectors: intDict.Count > 0 ? intDict : null,
+        realVectors: realDict.Count > 0 ? realDict : null,
+        permutations: permDict.Count > 0 ? permDict : null);
+      return new Individual(binDict, intDict, realDict, permDict);
+    }
     internal static void Write(IScope scope, ParameterVector vector) {
+    internal static void Write(IScope scope, Individual vector) {
       foreach (var param in vector.BinaryNames) {
         if (scope.Variables.ContainsKey(param))

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

-                      r11405
+                      r11484
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Datastructures\PermutationParameterConfiguration.cs" />
     <Compile Include="Datastructures\RealParameterConfiguration.cs" />
     <Compile Include="Datastructures\IntegerParameterConfiguration.cs" />
     <Compile Include="Datastructures\BinaryParameterConfiguration.cs" />
     <Compile Include="Datastructures\Configuration.cs" />
     <Compile Include="Datastructures\ParameterConfiguration.cs" />
     <Compile Include="Datastructures\ParameterVector.cs" />
+    <Compile Include="Encodings\PermutationEncoding.cs" />
+    <Compile Include="Encodings\RealEncoding.cs" />
+    <Compile Include="Encodings\IntegerEncoding.cs" />
+    <Compile Include="Encodings\BinaryEncoding.cs" />
+    <Compile Include="Encodings\MultiEncoding.cs" />
+    <Compile Include="Encodings\Encoding.cs" />
+    <Compile Include="Encodings\Individual.cs" />
     <Compile Include="Helper.cs" />
+    <Compile Include="Interfaces\IParameterVectorMoveOperator.cs" />
+    <Compile Include="Interfaces\IMultiObjectiveProblemDefinitionHost.cs" />
+    <Compile Include="Interfaces\ISingleObjectiveMoveOperator.cs" />
     <Compile Include="Interfaces\IMultiObjectiveProblemDefinition.cs" />
-    <Compile Include="Interfaces\ISingleObjectiveProblemDefinitionHost.cs" />
     <Compile Include="Interfaces\IMultiObjectiveProgrammableProblemAnalyzer.cs" />
     <Compile Include="Interfaces\ISingleObjectiveProgrammableProblemAnalyzer.cs" />
     <Compile Include="Interfaces\IMultiObjectiveProgrammableProblemEvaluator.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\MultiEncodingManipulator.cs" />
+    <Compile Include="Operators\MultiEncodingCrossover.cs" />
+    <Compile Include="Operators\SingleObjectiveMoveEvaluator.cs" />
+    <Compile Include="Operators\SingleObjectiveMoveGenerator.cs" />
+    <Compile Include="Operators\SingleObjectiveMoveMaker.cs" />
     <Compile Include="Operators\MultiObjectiveAnalyzer.cs" />
     <Compile Include="Operators\SingleObjectiveAnalyzer.cs" />
     <Compile Include="Operators\MultiObjectiveEvaluator.cs" />
     <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorCreater.cs" />
+    <Compile Include="Operators\MultiEncodingCreator.cs" />
     <Compile Include="Interfaces\IProblemDefinition.cs" />
     <Compile Include="Interfaces\ISingleObjectiveProblemDefinition.cs" />
     <Compile Include="Operators\SingleObjectiveParameterVectorImprover.cs" />
+    <Compile Include="Operators\SingleObjectiveImprover.cs" />
     <Compile Include="ProblemDefinition.cs" />
+    <Compile Include="ProblemDefinitionScript.cs" />
+    <Compile Include="ProblemScriptBase.cs" />
+    <Compile Include="ProblemScript.cs" />
     <Compile Include="MultiObjectiveProblemDefinition.cs" />
     <Compile Include="SingleObjectiveProblemDefinition.cs" />
     <Compile Include="MultiObjectiveProblemDefinitionScript.cs" />
     <Compile Include="SingleObjectiveProblemDefinitionScript.cs" />
+    <Compile Include="MultiObjectiveProblemScript.cs" />
+    <Compile Include="SingleObjectiveProblemScript.cs" />
     <Compile Include="MultiObjectiveProgrammableProblem.cs" />
     <Compile Include="SingleObjectiveProgrammableProblem.cs" />

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs

-                      r11400
+                      r11484
 #endregion
-using System.Collections.Generic;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 …
   public interface IMultiObjectiveProblemDefinition : IProblemDefinition {
     bool[] Maximization { get; }
+    double[] Evaluate(IRandom random, ParameterVector vector);
+    void Analyze(ParameterVector[] vectors, double[][] qualities, ResultCollection results);
+    IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector);
+    double[] Evaluate(IRandom random, Individual individual);
+    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results);
+  }
+}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs

-                      r11400
+                      r11484
 namespace HeuristicLab.Problems.Programmable {
   public interface IMultiObjectiveProgrammableProblemAnalyzer : IAnalyzer {
     ILookupParameter<IMultiObjectiveProblemDefinitionHost> ProblemDefinitionParameter { get; }
     ILookupParameter<Configuration> ConfigurationParameter { get; }
+    ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
     IScopeTreeLookupParameter<DoubleArray> QualitiesParameter { get; }
     ILookupParameter<ResultCollection> ResultsParameter { get; }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs

r11400	r11484
25	25	namespace HeuristicLab.Problems.Programmable {
26	26	public interface IMultiObjectiveProgrammableProblemEvaluator : IMultiObjectiveEvaluator {
27		ILookupParameter<IMultiObjectiveProblemDefinition~~Host~~> ProblemDefinitionParameter { get; }
28		ILookupParameter<~~Configuration> Configuration~~Parameter { get; }
	27	ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
	28	ILookupParameter<Encoding> EncodingParameter { get; }
29	29	}
30	30	}

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

-                      r11402
+                      r11484
 #endregion
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Core;
 namespace HeuristicLab.Problems.Programmable {
+  public interface IProblemDefinition {
+    Configuration GetConfiguration();
+  public interface IProblemDefinition : INamedItem {
+    Encoding Encoding { get; }
+    IEnumerable<Individual> GetNeighbors(IRandom random, Individual individual);
+    event EventHandler ProblemDefinitionChanged;
+  }
+}

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

-                      r11393
+                      r11484
 #endregion
-using System.Collections.Generic;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
 …
   public interface ISingleObjectiveProblemDefinition : IProblemDefinition {
     bool IsMaximizationProblem { get; }
+    double Evaluate(IRandom random, ParameterVector vector);
+    void Analyze(ParameterVector[] vectors, double[] qualities, ResultCollection results);
+    IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector);
+    double Evaluate(IRandom random, Individual individual);
+    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results);
+  }
+}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs

-                      r11396
+                      r11484
 namespace HeuristicLab.Problems.Programmable {
   public interface ISingleObjectiveProgrammableProblemAnalyzer : IAnalyzer {
     ILookupParameter<ISingleObjectiveProblemDefinitionHost> ProblemDefinitionParameter { get; }
     ILookupParameter<Configuration> ConfigurationParameter { get; }
+    ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
+    ILookupParameter<Encoding> EncodingParameter { get; }
     IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
     ILookupParameter<ResultCollection> ResultsParameter { get; }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs

r11396	r11484
25	25	namespace HeuristicLab.Problems.Programmable {
26	26	public interface ISingleObjectiveProgrammableProblemEvaluator : ISingleObjectiveEvaluator {
27		ILookupParameter<ISingleObjectiveProblemDefinition~~Host~~> ProblemDefinitionParameter { get; }
28		ILookupParameter<~~Configuration> Configuration~~Parameter { get; }
	27	ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
	28	ILookupParameter<Encoding> EncodingParameter { get; }
29	29	}
30	30	}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs

-                      r11402
+                      r11484
 #endregion
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 namespace HeuristicLab.Problems.Programmable {
+  [Item("Multi-objective Problem Definition", "This definition can be dynamically created through code and assigned to the problem.")]
+  public class MultiObjectiveProblemDefinition : IMultiObjectiveProblemDefinitionHost, IMultiObjectiveProblemDefinition {
+  [Item("Multi-objective Problem Definition", "Base class for custom multi-objective problem definitions.")]
+  public abstract class MultiObjectiveProblemDefinition : ProblemDefinition, IMultiObjectiveProblemDefinition {
+    [Storable(Name = "Storable")]
     private bool[] maximization;
     public bool[] Maximization {
       get { return maximization; }
       set {
+        if (maximization.SequenceEqual(value)) return;
         maximization = value;
         OnInstanceChanged();
+        OnProblemDefinitionChanged();
+      }
+    }
+    private Func<Configuration> configuration;
+    public Func<Configuration> Configuration {
+      get { return configuration; }
+      set {
+        configuration = value;
+        OnInstanceChanged();
+      }
+    public abstract double[] Evaluate(IRandom random, Individual vector);
+    public abstract void Analyze(Individual[] vectors, double[][] qualities, ResultCollection results);
+    [StorableConstructor]
+    protected MultiObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner)
+      : base(original, cloner) {
+      this.maximization = (bool[])original.maximization.Clone();
+    }
+    private Func<IRandom, ParameterVector, double[]> evaluate;
+    public Func<IRandom, ParameterVector, double[]> Evaluate {
+      get { return evaluate; }
+      set {
+        evaluate = value;
+        OnInstanceChanged();
+      }
+    }
+    private Action<ParameterVector[], double[][], ResultCollection> analyze;
+    public Action<ParameterVector[], double[][], ResultCollection> Analyze {
+      get { return analyze; }
+      set {
+        analyze = value;
+        OnInstanceChanged();
+      }
+    }
+    private Func<IRandom, ParameterVector, IEnumerable<ParameterVector>> neighbors;
+    public Func<IRandom, ParameterVector, IEnumerable<ParameterVector>> Neighbors {
+      get { return neighbors; }
+      set {
+        neighbors = value;
+        OnInstanceChanged();
+      }
+    }
+    protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      name = original.name;
+      description = original.description;
+      maximization = original.maximization;
+      configuration = original.configuration;
+      evaluate = original.evaluate;
+      analyze = original.analyze;
+      neighbors = original.neighbors;
+    }
+    public MultiObjectiveProblemDefinition() : this((string)null, null) { }
+    public MultiObjectiveProblemDefinition(string name) : this(name, null) { }
+    public MultiObjectiveProblemDefinition(string name, string description) {
+      this.name = name ?? ItemName;
+      this.description = description ?? ItemDescription;
+      configuration = () => new Configuration();
+      evaluate = (random, vector) => new[] { 0.0, 0.0 };
+      analyze = (vectors, doubles, results) => { };
+      neighbors = (random, vector) => new[] { (ParameterVector)vector.Clone() };
+    }
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveProblemDefinition(this, cloner);
+    }
+    public IMultiObjectiveProblemDefinition Instance {
+      get { return this; }
+    }
+    public event EventHandler InstanceChanged;
+    protected void OnInstanceChanged() {
+      var handler = InstanceChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #region Problem definition explicit interface implementations
+    Configuration IProblemDefinition.GetConfiguration() {
+      return Configuration();
+    }
+    bool[] IMultiObjectiveProblemDefinition.Maximization {
+      get { return Maximization; }
+    }
+    double[] IMultiObjectiveProblemDefinition.Evaluate(IRandom random, ParameterVector vector) {
+      return Evaluate(random, vector);
+    }
+    void IMultiObjectiveProblemDefinition.Analyze(ParameterVector[] vectors, double[][] qualities, ResultCollection results) {
+      Analyze(vectors, qualities, results);
+    }
+    IEnumerable<ParameterVector> IMultiObjectiveProblemDefinition.GetNeighbors(IRandom random, ParameterVector vector) {
+      return Neighbors(random, vector);
+    }
+    #endregion
+    #region INamedItem
+    protected string name;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnNameChanging"/> and also <see cref="OnNameChanged"/>
+    /// eventually in the setter.</remarks>
+    public string Name {
+      get { return name; }
+      set {
+        if (!CanChangeName) throw new NotSupportedException("Name cannot be changed.");
+        if (!(name.Equals(value) || (value == null) && (name == string.Empty))) {
+          CancelEventArgs<string> e = value == null ? new CancelEventArgs<string>(string.Empty) : new CancelEventArgs<string>(value);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            name = value == null ? string.Empty : value;
+            OnNameChanged();
+          }
+        }
+      }
+    }
+    public virtual bool CanChangeName {
+      get { return true; }
+    }
+    protected string description;
+    public string Description {
+      get { return description; }
+      set {
+        if (!CanChangeDescription) throw new NotSupportedException("Description cannot be changed.");
+        if (!(description.Equals(value) || (value == null) && (description == string.Empty))) {
+          description = value == null ? string.Empty : value;
+          OnDescriptionChanged();
+        }
+      }
+    }
+    public virtual bool CanChangeDescription {
+      get { return true; }
+    }
+    /// <summary>
+    /// Gets the string representation of the current instance in the format: <c>Name: [null|Value]</c>.
+    /// </summary>
+    /// <returns>The current instance as a string.</returns>
+    public override string ToString() {
+      return Name;
+    }
+    /// <inheritdoc/>
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    /// <summary>
+    /// Fires a new <c>NameChanging</c> event.
+    /// </summary>
+    /// <param name="e">The event arguments of the changing.</param>
+    protected virtual void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+    /// <inheritdoc/>
+    public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnToStringChanged();
+    }
+    /// <inheritdoc/>
+    public event EventHandler DescriptionChanged;
+    /// <summary>
+    /// Fires a new <c>DescriptionChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+    #region IItem
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      var handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      var handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+    protected MultiObjectiveProblemDefinition(Encoding encoding) : this(encoding, "MultiObjectiveProblemDefinition", null) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
+    protected MultiObjectiveProblemDefinition(Encoding encoding, string name, string description)
+      : base(encoding) { }
+  }
+}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs

-                      r11400
+                      r11484
+    }
     public IValueParameter<IMultiObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (IValueParameter<IMultiObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    }
     protected IValueParameter<Configuration> ConfigurationParameter {
       get { return (IValueParameter<Configuration>)Parameters["Configuration"]; }
+    }
     public IMultiObjectiveProblemDefinitionHost ProblemDefinition {
+    public IValueParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (IValueParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+    protected IValueParameter<Encoding> EncodingParameter {
+      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
+    }
+    public IMultiObjectiveProblemDefinition ProblemDefinition {
       get { return ProblemDefinitionParameter.Value; }
       set { ProblemDefinitionParameter.Value = value; }
 …
     [Storable]
     protected List<IParameter> DynamicConfigurationParameters;
+    protected List<IParameter> DynamicEncodingParameters;
     [StorableConstructor]
 …
     protected MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem original, Cloner cloner)
       : base(original, cloner) {
       DynamicConfigurationParameters = original.DynamicConfigurationParameters.Select(cloner.Clone).ToList();
+      DynamicEncodingParameters = original.DynamicEncodingParameters.Select(cloner.Clone).ToList();
       RegisterEventHandlers();
+    }
     public MultiObjectiveProgrammableProblem()
       : base(new MultiObjectiveEvaluator(), new ParameterVectorCreater()) {
       Parameters.Add(new ValueParameter<IMultiObjectiveProblemDefinitionHost>("ProblemDefinition", "Defines the problem.", new MultiObjectiveProblemDefinitionScript() { 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."));
       DynamicConfigurationParameters = new List<IParameter>();
+      : base(new MultiObjectiveEvaluator(), new MultiEncodingCreator()) {
+      Parameters.Add(new ValueParameter<IMultiObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new MultiObjectiveProblemScript() { Name = Name }));
+      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes which parameters exist, what they're called, what type they are and their bounds if any."));
+      DynamicEncodingParameters = new List<IParameter>();
       Operators.Add(new MultiObjectiveAnalyzer());
 …
     private void RegisterHostInstanceChanges() {
       ProblemDefinitionParameter.Value.InstanceChanged += ProblemDefinitionHostOnInstanceChanged;
+      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
       ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
+    }
 …
+    }
     protected virtual void ProblemDefinitionHostOnInstanceChanged(object sender, EventArgs eventArgs) {
+    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
       Parameterize();
+    }
     protected virtual void Parameterize() {
       var instance = ProblemDefinitionParameter.Value.Instance;
       if (instance == null) return;
       Configuration configuration;
+      var definition = ProblemDefinitionParameter.Value;
+      if (definition == null) return;
+      Encoding encoding;
       try {
         configuration = instance.GetConfiguration();
+        encoding = definition.Encoding;
       } catch { return; }
       ConfigurationParameter.Value = configuration;
       Maximization = new BoolArray(instance.Maximization);
       Evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      EncodingParameter.Value = encoding;
+      Maximization = new BoolArray(definition.Maximization);
+      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
       Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
       foreach (var evalOp in Operators.OfType<IMultiObjectiveProgrammableProblemEvaluator>()) {
         evalOp.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
         evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
       foreach (var analyzeOp in Operators.OfType<IMultiObjectiveProgrammableProblemAnalyzer>()) {
         analyzeOp.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
         analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
         analyzeOp.QualitiesParameter.ActualName = Evaluator.QualitiesParameter.ActualName;
+      }
+      var solutionCreators = UpdateDynamicConfigurationParameters(configuration);
+      if (solutionCreators.Count == 1) {
+        Operators.RemoveAll(x => x is ParameterVectorCrossover
+                              || x is ParameterVectorManipulator);
+        UpdateSingleVectorEncodingOperators(solutionCreators, configuration);
+      } else {
+        UpdateMultiVectorEncodingOperators(solutionCreators, configuration);
+      }
+      UpdateMoveOperators();
+    }
+    protected virtual List<ISolutionCreator> UpdateDynamicConfigurationParameters(Configuration configuration) {
+      foreach (var param in DynamicConfigurationParameters)
+      foreach (var param in DynamicEncodingParameters)
         if (Parameters.Contains(param)) Parameters.Remove(param);
+      DynamicConfigurationParameters.Clear();
+      var solutionCreators = new List<ISolutionCreator>();
+      foreach (var param in configuration.Parameters) {
+        #region Configure BinaryVector Creator
+        var binConfig = param.Value as BinaryParameterConfiguration;
+        if (binConfig != null) {
+          var p = new ValueParameter<IntValue>(param.Key + "Length", binConfig.Length);
+          DynamicConfigurationParameters.Add(p);
+          var creator = new RandomBinaryVectorCreator();
+          creator.BinaryVectorParameter.ActualName = param.Key;
+          creator.LengthParameter.ActualName = p.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure IntegerVector Creator
+        var intConfig = param.Value as IntegerParameterConfiguration;
+        if (intConfig != null) {
+          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 = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.BoundsParameter.ActualName = b.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure RealVector Creator
+        var realConfig = param.Value as RealParameterConfiguration;
+        if (realConfig != null) {
+          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 = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.BoundsParameter.ActualName = b.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure Permutation Creator
+        var permConfig = param.Value as PermutationParameterConfiguration;
+        if (permConfig != null) {
+          var l = new ValueParameter<IntValue>(param.Key + "Length", permConfig.Length);
+          DynamicConfigurationParameters.Add(l);
+          var creator = new RandomPermutationCreator();
+          creator.PermutationParameter.ActualName = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.PermutationTypeParameter.Value = permConfig.Type;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+      }
+      foreach (var param in DynamicConfigurationParameters) {
+      DynamicEncodingParameters.Clear();
+      var creator = ConfigureCreator(encoding);
+      foreach (var param in DynamicEncodingParameters) {
         param.Hidden = true;
         Parameters.Add(param);
+      }
+      return solutionCreators;
+    }
+    protected virtual void UpdateSingleVectorEncodingOperators(List<ISolutionCreator> solutionCreators, Configuration configuration) {
+      var newCreator = solutionCreators.Single();
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        ConfigureMultiVectorEncodingOperators((MultiEncodingCreator)creator, multiEncoding);
+      } else {
+        ConfigureSingleEncodingOperators(creator, encoding);
+      }
+    }
+    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+      #region Configure MultiEncoding Creator
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        var creator = new MultiEncodingCreator();
+        foreach (var enc in multiEncoding.Encodings) {
+          if (enc is MultiEncoding) throw new InvalidOperationException("MultiEncoding within a MultiEncoding is not supported.");
+          creator.Operators.Add(ConfigureCreator(enc));
+        }
+        return creator;
+      }
+      #endregion
+      #region Configure BinaryVector Creator
+      var binEnc = encoding as BinaryEncoding;
+      if (binEnc != null) {
+        var p = new ValueParameter<IntValue>(binEnc.Name + "Length", binEnc.Length);
+        DynamicEncodingParameters.Add(p);
+        var creator = new RandomBinaryVectorCreator();
+        creator.BinaryVectorParameter.ActualName = binEnc.Name;
+        creator.LengthParameter.ActualName = p.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      var intEnc = encoding as IntegerEncoding;
+      if (intEnc != null) {
+        var l = new ValueParameter<IntValue>(intEnc.Name + "Length", intEnc.Length);
+        var b = new ValueParameter<IntMatrix>(intEnc.Name + "Bounds", intEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+        var creator = new UniformRandomIntegerVectorCreator();
+        creator.IntegerVectorParameter.ActualName = intEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure RealVector Creator
+      var realEnc = encoding as RealEncoding;
+      if (realEnc != null) {
+        var l = new ValueParameter<IntValue>(realEnc.Name + "Length", realEnc.Length);
+        var b = new ValueParameter<DoubleMatrix>(realEnc.Name + "Bounds", realEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+        var creator = new UniformRandomRealVectorCreator();
+        creator.RealVectorParameter.ActualName = realEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure Permutation Creator
+      var permEnc = encoding as PermutationEncoding;
+      if (permEnc != null) {
+        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
+        DynamicEncodingParameters.Add(l);
+        var creator = new RandomPermutationCreator();
+        creator.PermutationParameter.ActualName = permEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.PermutationTypeParameter.Value = permEnc.Type;
+        return creator;
+      }
+      #endregion
+      throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
+    }
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+      // remove all multiencoding operators
+      Operators.RemoveAll(x => x is MultiEncodingCrossover
+                            || x is MultiEncodingManipulator
+                            || x is MultiEncodingCreator);
       #region Configure Operators for BinaryVectorEncoding
       var binCreator = newCreator as IBinaryVectorCreator;
 …
         #region Wire BinaryVector Crossovers
+        Operators.RemoveAll(x => x is IBinaryVectorCrossover && ((IBinaryVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IBinaryVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>(), new TypeEqualityComparer<IBinaryVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
 …
           xo.ParentsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IBinaryVectorCrossover>()));
         #endregion
         #region Wire BinaryVector Manipulators
+        Operators.RemoveAll(x => x is IBinaryVectorManipulator && ((IBinaryVectorManipulator)x).BinaryVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IBinaryVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>(), new TypeEqualityComparer<IBinaryVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
           m.BinaryVectorParameter.Hidden = true;
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IBinaryVectorManipulator>()));
         #endregion
         #region Wire BinaryVector ShakingOperators
+        Operators.RemoveAll(x => x is IBinaryVectorMultiNeighborhoodShakingOperator && ((IBinaryVectorManipulator)x).BinaryVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IBinaryVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.BinaryVectorParameter.ActualName = paramName;
           so.BinaryVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire IntegerVector Crossovers
+        Operators.RemoveAll(x => x is IIntegerVectorCrossover && ((IIntegerVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IIntegerVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>(), new TypeEqualityComparer<IIntegerVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
 …
+          }
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IIntegerVectorCrossover>()));
         #endregion
         #region Wire IntegerVector Manipulators
+        Operators.RemoveAll(x => x is IIntegerVectorManipulator && ((IIntegerVectorManipulator)x).IntegerVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IIntegerVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>(), new TypeEqualityComparer<IIntegerVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
 …
+          }
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IIntegerVectorManipulator>()));
         #region Wire IntegerVector StrategyParameters for SelfAdaptiveManipulators
+        Operators.RemoveAll(x => x is IStrategyParameterCreator && !(x is IIntegerVectorStdDevStrategyParameterCreator) || x is IIntegerVectorStdDevStrategyParameterCreator && ((IIntegerVectorStdDevStrategyParameterCreator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterManipulator && !(x is IIntegerVectorStdDevStrategyParameterManipulator) || x is IIntegerVectorStdDevStrategyParameterManipulator && ((IIntegerVectorStdDevStrategyParameterManipulator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterCrossover && !(x is IIntegerVectorStdDevStrategyParameterCrossover) || x is IIntegerVectorStdDevStrategyParameterCrossover && ((IIntegerVectorStdDevStrategyParameterCrossover)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        var strategyOperators = ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>().ToList();
+        if (!(configuration.Parameters.First().Value is IntegerParameterConfiguration)) throw new InvalidOperationException("Single-encoded problem with integervector creator that is not an integer-coded problem.");
+        var problemSize = ((IntegerParameterConfiguration)configuration.Parameters.First().Value).Length.Value;
+        var b = ((IntegerParameterConfiguration)configuration.Parameters.First().Value).Bounds;
+        var strategyOperators = Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IIntegerVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((IntegerEncoding)encoding).Length.Value;
+        var b = ((IntegerEncoding)encoding).Bounds;
         var bounds = new DoubleMatrix(b.Rows, b.Columns);
         for (var i = 0; i < bounds.Rows; i++) {
 …
+          }
+        }
         Operators.AddRange(strategyOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()));
         #endregion
         #endregion
         #region Wire IntegerVector ShakingOperators
+        Operators.RemoveAll(x => x is IIntegerVectorMultiNeighborhoodShakingOperator && ((IIntegerVectorMultiNeighborhoodShakingOperator)x).IntegerVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IIntegerVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.IntegerVectorParameter.ActualName = paramName;
           so.IntegerVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire RealVector Crossovers
+        Operators.RemoveAll(x => x is IRealVectorCrossover && ((IRealVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IRealVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IRealVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = paramName;
 …
           xo.BoundsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
         #endregion
         #region Wire RealVector Manipulators
+        Operators.RemoveAll(x => x is IRealVectorManipulator && ((IRealVectorManipulator)x).RealVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IRealVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IRealVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.RealVectorParameter.ActualName = paramName;
 …
+          }
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
         #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
+        Operators.RemoveAll(x => x is IStrategyParameterCreator && !(x is IRealVectorStdDevStrategyParameterCreator) || x is IRealVectorStdDevStrategyParameterCreator && ((IRealVectorStdDevStrategyParameterCreator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterManipulator && !(x is IRealVectorStdDevStrategyParameterManipulator) || x is IRealVectorStdDevStrategyParameterManipulator && ((IRealVectorStdDevStrategyParameterManipulator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterCrossover && !(x is IRealVectorStdDevStrategyParameterCrossover) || x is IRealVectorStdDevStrategyParameterCrossover && ((IRealVectorStdDevStrategyParameterCrossover)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        var strategyOperators = ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>().ToList();
+        if (!(configuration.Parameters.First().Value is RealParameterConfiguration)) throw new InvalidOperationException("Single-encoded problem with realvector creator that is not a real-coded problem.");
+        var problemSize = ((RealParameterConfiguration)configuration.Parameters.First().Value).Length.Value;
+        var bounds = (DoubleMatrix)((RealParameterConfiguration)configuration.Parameters.First().Value).Bounds.Clone();
+        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((RealEncoding)encoding).Length.Value;
+        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
         for (var i = 0; i < bounds.Rows; i++) {
           bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
 …
+          }
+        }
         Operators.AddRange(strategyOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
         #endregion
         #endregion
         #region Wire RealVector ParticleCreators
+        Operators.RemoveAll(x => x is IRealVectorParticleCreator && ((IRealVectorParticleCreator)x).RealVectorParameter.ActualName != paramName);
+        var particleCreators = ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>().ToList();
+        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
+          .ToList();
         foreach (var pc in particleCreators) {
           pc.RealVectorParameter.ActualName = paramName;
 …
           pc.ProblemSizeParameter.Hidden = true;
+        }
         Operators.AddRange(particleCreators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
         #endregion
         #region Wire RealVector ParticleUpdaters
+        Operators.RemoveAll(x => x is IRealVectorParticleUpdater && ((IRealVectorParticleUpdater)x).RealVectorParameter.ActualName != paramName);
+        var particleUpdaters = ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>().ToList();
+        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
+          .ToList();
         foreach (var pu in particleUpdaters) {
           pu.RealVectorParameter.ActualName = paramName;
 …
           pu.BoundsParameter.Hidden = true;
+        }
         Operators.AddRange(particleUpdaters.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
         #endregion
         #region Wire RealVector SwarmUpdaters
+        Operators.RemoveAll(x => x is IRealVectorSwarmUpdater && ((IRealVectorSwarmUpdater)x).RealVectorParameter.ActualName != paramName);
+        var swarmUpdaters = ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>().ToList();
+        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
+          .ToList();
         foreach (var su in swarmUpdaters) {
           su.RealVectorParameter.ActualName = paramName;
 …
           su.MaximizationParameter.Hidden = true;
+        }
         Operators.AddRange(swarmUpdaters.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
         #endregion
         #region Wire RealVector ShakingOperators
+        Operators.RemoveAll(x => x is IRealVectorMultiNeighborhoodShakingOperator && ((IRealVectorMultiNeighborhoodShakingOperator)x).RealVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.RealVectorParameter.ActualName = paramName;
           so.RealVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire Permutation Crossovers
+        Operators.RemoveAll(x => x is IPermutationCrossover && ((IPermutationCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IPermutationCrossover>().ToList();
+        var crossovers = Operators.OfType<IPermutationCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
 …
           xo.ParentsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
         #endregion
         #region Wire Permutation Manipulators
+        Operators.RemoveAll(x => x is IPermutationManipulator && ((IPermutationManipulator)x).PermutationParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IPermutationManipulator>().ToList();
+        var manipulators = Operators.OfType<IPermutationManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
           m.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        #endregion
+        #region Wire ShakingOperators
+        Operators.RemoveAll(x => x is IPermutationMultiNeighborhoodShakingOperator && ((IPermutationMultiNeighborhoodShakingOperator)x).PermutationParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>().ToList();
+        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
+        #endregion
+        #region Wire Permutation ShakingOperators
+        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var op in shakingOperators) {
           op.PermutationParameter.ActualName = paramName;
           op.PermutationParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
+    }
+    protected virtual void UpdateMultiVectorEncodingOperators(List<ISolutionCreator> solutionCreators, Configuration configuration) {
+      var oldCreator = SolutionCreator as ParameterVectorCreater;
+      var newCreator = new ParameterVectorCreater();
+      #region Configure BinaryVector Creator
+      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);
+    protected virtual void ConfigureMultiVectorEncodingOperators(MultiEncodingCreator newCreator, MultiEncoding encoding) {
+      var newBinParams = new HashSet<string>(newCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+      var newIntParams = new HashSet<string>(newCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+      var newRealParams = new HashSet<string>(newCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+      var newPermParams = new HashSet<string>(newCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+      var oldCreator = SolutionCreator as MultiEncodingCreator;
+      if (oldCreator == null) SolutionCreator = newCreator;
+      else {
+        #region Configure BinaryVector Creator
+        var oldBinParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+        foreach (var toAdd in newBinParams.Except(oldBinParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+          var op = oldCreator.Operators.OfType<IBinaryVectorCreator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      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);
+        #endregion
+        #region Configure IntegerVector Creator
+        var oldIntParams = new HashSet<string>(oldCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+        foreach (var toAdd in newIntParams.Except(oldIntParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+          var op = oldCreator.Operators.OfType<IIntegerVectorCreator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure RealVector Creator
+      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);
+        #endregion
+        #region Configure RealVector Creator
+        var oldRealParams = new HashSet<string>(oldCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+        foreach (var toAdd in newRealParams.Except(oldRealParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+          var op = oldCreator.Operators.OfType<IRealVectorCreator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure Permutation Creator
+      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);
+        #endregion
+        #region Configure Permutation Creator
+        var oldPermParams = new HashSet<string>(oldCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+        foreach (var toAdd in newPermParams.Except(oldPermParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+          var op = oldCreator.Operators.OfType<IPermutationCreator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
           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);
+        foreach (var intersect in newPermParams.Intersect(oldPermParams)) {
+          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          var newPermCreator = newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
           oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
+        }
+      } else {
+        // we will use the new creator
+        foreach (var permCreator in solutionCreators.OfType<IPermutationCreator>()) {
+          newCreator.Operators.Add(permCreator);
+        }
+      }
+      #endregion
+      if (oldCreator == null) SolutionCreator = newCreator;
+        #endregion
+      }
       // 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()) {
+      if (Operators.OfType<MultiEncodingCrossover>().Any() && Operators.OfType<MultiEncodingManipulator>().Any()) {
         #region Update existing multi-vector encoding
         #region Update ParameterVector Crossover ...
         foreach (var oldXo in Operators.OfType<ParameterVectorCrossover>()) {
+        foreach (var oldXo in Operators.OfType<MultiEncodingCrossover>()) {
           #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, encoding));
           foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, encoding));
           foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldXo.Operators.OfType<IIntegerVectorCrossover>()
+                .SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IIntegerVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, encoding));
           foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, encoding));
           foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
 …
         #endregion
         #region Update ParameterVector Manipulator ...
         foreach (var oldM in Operators.OfType<ParameterVectorManipulator>()) {
+        foreach (var oldM in Operators.OfType<MultiEncodingManipulator>()) {
           #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>()
+            .Select(x => x.BinaryVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, encoding));
           foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldM.Operators.OfType<IBinaryVectorManipulator>()
+                .SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IBinaryVectorManipulator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>()
+            .Select(x => x.IntegerVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, encoding));
           foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldM.Operators.OfType<IIntegerVectorManipulator>()
+                .SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IIntegerVectorManipulator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>()
+            .Select(x => x.RealVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, encoding));
           foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldM.Operators.OfType<IRealVectorManipulator>()
+                .SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IRealVectorManipulator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>()
+            .Select(x => x.PermutationParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, encoding));
           foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldM.Operators.OfType<IPermutationManipulator>()
+                .SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IPermutationManipulator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
 …
         Operators.RemoveAll(x => x is IMultiNeighborhoodShakingOperator);
         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));
+        var crossover = new MultiEncodingCrossover();
+        var manipulator = new MultiEncodingManipulator();
+        foreach (var enc in encoding.Encodings) {
+          if (enc is BinaryEncoding) {
+            crossover.Operators.Add(GetDefaultBinaryCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultBinaryManipulator(enc.Name, encoding));
             continue;
+          }
           var intConfig = param.Value as IntegerParameterConfiguration;
+          var intConfig = enc as IntegerEncoding;
           if (intConfig != null) {
             crossover.Operators.Add(GetDefaultIntegerCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultIntegerManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultIntegerCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultIntegerManipulator(enc.Name, encoding));
             continue;
+          }
           var realConfig = param.Value as RealParameterConfiguration;
+          var realConfig = enc as RealEncoding;
           if (realConfig != null) {
             crossover.Operators.Add(GetDefaultRealCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultRealManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultRealCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultRealManipulator(enc.Name, encoding));
             continue;
+          }
           var permConfig = param.Value as PermutationParameterConfiguration;
+          var permConfig = enc as PermutationEncoding;
           if (permConfig != null) {
             crossover.Operators.Add(GetDefaultPermutationCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultPermutationManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultPermutationCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultPermutationManipulator(enc.Name, encoding));
             continue;
+          }
           throw new InvalidOperationException("Unknown type for parameter " + param.Key);
+          throw new InvalidOperationException("Unknown type for parameter " + enc.Name);
+        }
         Operators.Add(crossover);
 …
+    }
-    protected virtual void UpdateMoveOperators() {
-      Operators.RemoveAll(x => x is IParameterVectorMoveOperator);
-      var generator = new ParameterVectorMoveGenerator();
-      generator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
-      generator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      var evaluator = new ParameterVectorMoveEvaluator();
-      evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
-      evaluator.QualityParameter.ActualName = Evaluator.QualitiesParameter.ActualName;
-      evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
-      var maker = new ParameterVectorMoveMaker();
-      maker.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
-      maker.MoveQualityParameter.ActualName = evaluator.MoveQualityParameter.ActualName;
-      maker.QualityParameter.ActualName = Evaluator.QualitiesParameter.ActualName;
-      Operators.AddRange(new IItem[] { generator, evaluator, maker });
+    }
     #region GetDefaultOperators for Crossovers and Manipulators
     // ReSharper disable RedundantNameQualifier
     protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, Configuration config) {
       var binConfig = (BinaryParameterConfiguration)config.Parameters[paramName];
+    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, MultiEncoding config) {
+      var binConfig = (BinaryEncoding)config.Encodings[paramName];
       IBinaryVectorCrossover binXo;
       if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
 …
+    }
     protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, Configuration config) {
+    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, MultiEncoding config) {
       var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
       binM.BinaryVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, Configuration config) {
+    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, MultiEncoding config) {
       var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaCrossover();
       intXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, Configuration configuration) {
+    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, MultiEncoding configuration) {
       var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
       intM.IntegerVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, Configuration configuration) {
+    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, MultiEncoding configuration) {
       var realXo = new Encodings.RealVectorEncoding.BlendAlphaCrossover();
       realXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, Configuration configuration) {
+    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, MultiEncoding configuration) {
       var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
       realM.RealVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, Configuration configuration) {
+    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, MultiEncoding configuration) {
       var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
       permXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, Configuration configuration) {
+    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, MultiEncoding configuration) {
       var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
       permM.PermutationParameter.ActualName = paramName;

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs

-                      r11400
+                      r11484
 namespace HeuristicLab.Problems.Programmable {
   [Item("Multi-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
+  [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
   [StorableClass]
   public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveProgrammableProblemAnalyzer {
     public bool EnabledByDefault { get { return true; } }
     public ILookupParameter<IMultiObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (ILookupParameter<IMultiObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    public ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
     public ILookupParameter<Configuration> ConfigurationParameter {
       get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
 …
     public MultiObjectiveAnalyzer() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       Parameters.Add(new LookupParameter<IMultiObjectiveProblemDefinitionHost>("ProblemDefinition", "The host that holds the problem definition."));
       Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<IMultiObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
 …
     public override IOperation Apply() {
       var host = ProblemDefinitionParameter.ActualValue;
       if (host.Instance == null) throw new InvalidOperationException("Script instance is null, maybe the code doesn't compile.");
       var config = ConfigurationParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
 …
       var vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
       host.Instance.Analyze(vectors, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
+      definition.Analyze(vectors, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results);
       return base.Apply();
+    }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs

-                      r11400
+                      r11484
 namespace HeuristicLab.Problems.Programmable {
   [Item("Multi-objective Evaluator", "Calls the script's Evaluate method to get the quality values of the parameter vector.")]
+  [Item("Multi-objective Evaluator", "Calls the Evaluate method of the problem definition and writes the return value into the scope.")]
   [StorableClass]
   public class MultiObjectiveEvaluator : SingleSuccessorOperator, IMultiObjectiveProgrammableProblemEvaluator, IStochasticOperator {
 …
+    }
     public ILookupParameter<IMultiObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (ILookupParameter<IMultiObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    public ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<IMultiObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
     public ILookupParameter<Configuration> ConfigurationParameter {
       get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
 …
     public MultiObjectiveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       Parameters.Add(new LookupParameter<IMultiObjectiveProblemDefinitionHost>("ProblemDefinition", "The host that holds the problem definition."));
       Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<IMultiObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
+    }
 …
     public override IOperation Apply() {
       var random = RandomParameter.ActualValue;
       var host = ProblemDefinitionParameter.ActualValue;
       if (host.Instance == null) throw new InvalidOperationException("Script instance is null, maybe the code doesn't compile.");
       var config = ConfigurationParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
       var vector = Helper.Extract(ExecutionContext.Scope, config);
       QualitiesParameter.ActualValue = new DoubleArray(host.Instance.Evaluate(random, vector));
+      QualitiesParameter.ActualValue = new DoubleArray(definition.Evaluate(random, vector));
       return base.Apply();
+    }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs

-                      r11405
+                      r11484
     public bool EnabledByDefault { get { return true; } }
     public ILookupParameter<ISingleObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (ILookupParameter<ISingleObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
     public ILookupParameter<Configuration> ConfigurationParameter {
       get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
 …
     public SingleObjectiveAnalyzer() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       Parameters.Add(new LookupParameter<ISingleObjectiveProblemDefinitionHost>("ProblemDefinition", "The host that holds the problem definition."));
       Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
       Parameters.Add(new LookupParameter<ResultCollection>("Results", "The results collection to write to."));
 …
     public override IOperation Apply() {
       var host = ProblemDefinitionParameter.ActualValue;
       if (host.Instance == null) throw new InvalidOperationException("Problem definition is not available.");
       var config = ConfigurationParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null");
+      var config = EncodingParameter.ActualValue;
       var results = ResultsParameter.ActualValue;
 …
       var vectors = scopes.Select(scope => Helper.Extract(scope, config)).ToArray();
       host.Instance.Analyze(vectors, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
+      definition.Analyze(vectors, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results);
       return base.Apply();
+    }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs

-                      r11405
+                      r11484
+    }
     public ILookupParameter<ISingleObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (ILookupParameter<ISingleObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    public ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (ILookupParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
     public ILookupParameter<Configuration> ConfigurationParameter {
       get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    public ILookupParameter<Encoding> EncodingParameter {
+      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    }
 …
     public SingleObjectiveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       Parameters.Add(new LookupParameter<ISingleObjectiveProblemDefinitionHost>("ProblemDefinition", "The host that holds the problem definition."));
       Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "The host that holds the problem definition."));
+      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+    }
 …
     public override IOperation Apply() {
       var random = RandomParameter.ActualValue;
       var host = ProblemDefinitionParameter.ActualValue;
       if (host.Instance == null) throw new InvalidOperationException("Problem definition is not available.");
       var config = ConfigurationParameter.ActualValue;
+      var definition = ProblemDefinitionParameter.ActualValue;
+      if (definition == null) throw new InvalidOperationException("Problem definition is null.");
+      var config = EncodingParameter.ActualValue;
       var vector = Helper.Extract(ExecutionContext.Scope, config);
       QualityParameter.ActualValue = new DoubleValue(host.Instance.Evaluate(random, vector));
+      QualityParameter.ActualValue = new DoubleValue(definition.Evaluate(random, vector));
       return base.Apply();
+    }

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs

-                      r11402
+                      r11484
 #endregion
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 namespace HeuristicLab.Problems.Programmable {
+  public abstract class ProblemDefinition : IProblemDefinition {
+    public abstract Configuration GetConfiguration();
+  [Item("ProblemDefinition", "Base class for problem definitions.")]
+  [StorableClass]
+  public abstract class ProblemDefinition : NamedItem, IProblemDefinition {
+    [Storable(Name = "Encoding")]
+    private Encoding encoding;
+    public Encoding Encoding {
+      get { return encoding; }
+      protected set {
+        if (encoding == value) return;
+        encoding = value;
+        OnProblemDefinitionChanged();
+      }
+    }
+    public dynamic vars { get; set; }
+    public abstract void Initialize();
+    [StorableConstructor]
+    protected ProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected ProblemDefinition(ProblemDefinition original, Cloner cloner)
+      : base(original, cloner) {
+      this.encoding = cloner.Clone(original.encoding);
+    }
+    protected ProblemDefinition(Encoding encoding) : this(encoding, "ProblemDefinition") { }
+    protected ProblemDefinition(Encoding encoding, string name) : this(encoding, name, string.Empty) { }
+    protected ProblemDefinition(Encoding encoding, string name, string description)
+      : base(name, description) {
+      Encoding = encoding;
+    }
+    public event EventHandler ProblemDefinitionChanged;
+    protected void OnProblemDefinitionChanged() {
+      var handler = ProblemDefinitionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public abstract IEnumerable<Individual> GetNeighbors(IRandom random, Individual vector);
+  }
+}

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs

-                      r11402
+                      r11484
 #endregion
-using System;
-using System.Collections.Generic;
-using System.Drawing;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 namespace HeuristicLab.Problems.Programmable {
+  [Item("Single-objective Problem Definition", "This definition can be dynamically created through code and assigned to the problem.")]
+  public class SingleObjectiveProblemDefinition : ISingleObjectiveProblemDefinitionHost, ISingleObjectiveProblemDefinition {
+  [Item("Single-objective Problem Definition", "Base class for custom single-objective problem definitions.")]
+  [StorableClass]
+  public abstract class SingleObjectiveProblemDefinition : ProblemDefinition, ISingleObjectiveProblemDefinition {
+    [Storable(Name = "Storable")]
     private bool isMaximizationProblem;
     public bool IsMaximizationProblem {
       get { return isMaximizationProblem; }
       set {
+        if (isMaximizationProblem == value) return;
         isMaximizationProblem = value;
         OnInstanceChanged();
+        OnProblemDefinitionChanged();
+      }
+    }
+    private Func<Configuration> configuration;
+    public Func<Configuration> Configuration {
+      get { return configuration; }
+      set {
+        configuration = value;
+        OnInstanceChanged();
+      }
+    public abstract double Evaluate(IRandom random, Individual vector);
+    public abstract void Analyze(Individual[] vectors, double[] qualities, ResultCollection results);
+    [StorableConstructor]
+    protected SingleObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner)
+      : base(original, cloner) {
+      this.isMaximizationProblem = original.isMaximizationProblem;
+    }
+    private Func<IRandom, ParameterVector, double> evaluate;
+    public Func<IRandom, ParameterVector, double> Evaluate {
+      get { return evaluate; }
+      set {
+        evaluate = value;
+        OnInstanceChanged();
+      }
+    }
+    private Action<ParameterVector[], double[], ResultCollection> analyze;
+    public Action<ParameterVector[], double[], ResultCollection> Analyze {
+      get { return analyze; }
+      set {
+        analyze = value;
+        OnInstanceChanged();
+      }
+    }
+    private Func<IRandom, ParameterVector, IEnumerable<ParameterVector>> neighbors;
+    public Func<IRandom, ParameterVector, IEnumerable<ParameterVector>> Neighbors {
+      get { return neighbors; }
+      set {
+        neighbors = value;
+        OnInstanceChanged();
+      }
+    }
+    protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      name = original.name;
+      description = original.description;
+      isMaximizationProblem = original.isMaximizationProblem;
+      configuration = original.configuration;
+      evaluate = original.evaluate;
+      analyze = original.analyze;
+      neighbors = original.neighbors;
+    }
+    public SingleObjectiveProblemDefinition() : this((string)null, null) { }
+    public SingleObjectiveProblemDefinition(string name) : this(name, null) { }
+    public SingleObjectiveProblemDefinition(string name, string description) {
+      this.name = name ?? ItemName;
+      this.description = description ?? ItemDescription;
+      configuration = () => new Configuration();
+      evaluate = (random, vector) => 0;
+      analyze = (vectors, doubles, results) => { };
+      neighbors = (random, vector) => new[] { (ParameterVector)vector.Clone() };
+    }
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveProblemDefinition(this, cloner);
+    }
+    public ISingleObjectiveProblemDefinition Instance {
+      get { return this; }
+    }
+    public event EventHandler InstanceChanged;
+    protected void OnInstanceChanged() {
+      var handler = InstanceChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #region Problem definition explicit interface implementations
+    Configuration IProblemDefinition.GetConfiguration() {
+      return Configuration();
+    }
+    bool ISingleObjectiveProblemDefinition.IsMaximizationProblem {
+      get { return IsMaximizationProblem; }
+    }
+    double ISingleObjectiveProblemDefinition.Evaluate(IRandom random, ParameterVector vector) {
+      return Evaluate(random, vector);
+    }
+    void ISingleObjectiveProblemDefinition.Analyze(ParameterVector[] vectors, double[] qualities, ResultCollection results) {
+      Analyze(vectors, qualities, results);
+    }
+    IEnumerable<ParameterVector> ISingleObjectiveProblemDefinition.GetNeighbors(IRandom random, ParameterVector vector) {
+      return Neighbors(random, vector);
+    }
+    #endregion
+    #region INamedItem
+    protected string name;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnNameChanging"/> and also <see cref="OnNameChanged"/>
+    /// eventually in the setter.</remarks>
+    public string Name {
+      get { return name; }
+      set {
+        if (!CanChangeName) throw new NotSupportedException("Name cannot be changed.");
+        if (!(name.Equals(value) || (value == null) && (name == string.Empty))) {
+          CancelEventArgs<string> e = value == null ? new CancelEventArgs<string>(string.Empty) : new CancelEventArgs<string>(value);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            name = value == null ? string.Empty : value;
+            OnNameChanged();
+          }
+        }
+      }
+    }
+    public virtual bool CanChangeName {
+      get { return true; }
+    }
+    protected string description;
+    public string Description {
+      get { return description; }
+      set {
+        if (!CanChangeDescription) throw new NotSupportedException("Description cannot be changed.");
+        if (!(description.Equals(value) || (value == null) && (description == string.Empty))) {
+          description = value == null ? string.Empty : value;
+          OnDescriptionChanged();
+        }
+      }
+    }
+    public virtual bool CanChangeDescription {
+      get { return true; }
+    }
+    /// <summary>
+    /// Gets the string representation of the current instance in the format: <c>Name: [null|Value]</c>.
+    /// </summary>
+    /// <returns>The current instance as a string.</returns>
+    public override string ToString() {
+      return Name;
+    }
+    /// <inheritdoc/>
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    /// <summary>
+    /// Fires a new <c>NameChanging</c> event.
+    /// </summary>
+    /// <param name="e">The event arguments of the changing.</param>
+    protected virtual void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+    /// <inheritdoc/>
+    public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnToStringChanged();
+    }
+    /// <inheritdoc/>
+    public event EventHandler DescriptionChanged;
+    /// <summary>
+    /// Fires a new <c>DescriptionChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
+    protected virtual void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+    #region IItem
+    public virtual string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+    public virtual string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+    public static Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
+    }
+    public virtual Image ItemImage {
+      get { return ItemAttribute.GetImage(this.GetType()); }
+    }
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      var handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      var handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+    protected SingleObjectiveProblemDefinition(Encoding encoding) : this(encoding, "SingleObjectiveProblemDefinition", null) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding, string name) : this(encoding, name, null) { }
+    protected SingleObjectiveProblemDefinition(Encoding encoding, string name, string description)
+      : base(encoding) { }
+  }
+}

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

-                      r11424
+                      r11484
+    }
     public IValueParameter<ISingleObjectiveProblemDefinitionHost> ProblemDefinitionParameter {
       get { return (IValueParameter<ISingleObjectiveProblemDefinitionHost>)Parameters["ProblemDefinition"]; }
+    }
     protected IValueParameter<Configuration> ConfigurationParameter {
       get { return (IValueParameter<Configuration>)Parameters["Configuration"]; }
+    }
     public ISingleObjectiveProblemDefinitionHost ProblemDefinition {
+    public IValueParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter {
+      get { return (IValueParameter<ISingleObjectiveProblemDefinition>)Parameters["ProblemDefinition"]; }
+    }
+    protected IValueParameter<Encoding> EncodingParameter {
+      get { return (IValueParameter<Encoding>)Parameters["Encoding"]; }
+    }
+    public ISingleObjectiveProblemDefinition ProblemDefinition {
       get { return ProblemDefinitionParameter.Value; }
       set { ProblemDefinitionParameter.Value = value; }
 …
     [Storable]
     protected List<IParameter> DynamicConfigurationParameters;
+    protected List<IParameter> DynamicEncodingParameters;
     [StorableConstructor]
 …
     protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem original, Cloner cloner)
       : base(original, cloner) {
       DynamicConfigurationParameters = original.DynamicConfigurationParameters.Select(cloner.Clone).ToList();
+      DynamicEncodingParameters = original.DynamicEncodingParameters.Select(cloner.Clone).ToList();
       RegisterEventHandlers();
+    }
     public SingleObjectiveProgrammableProblem()
       : base(new SingleObjectiveEvaluator(), new ParameterVectorCreater()) {
       Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinitionHost>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemDefinitionScript() { 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."));
       DynamicConfigurationParameters = new List<IParameter>();
+      : base(new SingleObjectiveEvaluator(), new MultiEncodingCreator()) {
+      Parameters.Add(new ValueParameter<ISingleObjectiveProblemDefinition>("ProblemDefinition", "Defines the problem.", new SingleObjectiveProblemScript() { Name = Name }));
+      Parameters.Add(new ValueParameter<Encoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
+      DynamicEncodingParameters = new List<IParameter>();
       Operators.Add(new BestScopeSolutionAnalyzer());
 …
     private void RegisterHostInstanceChanges() {
       ProblemDefinitionParameter.Value.InstanceChanged += ProblemDefinitionHostOnInstanceChanged;
+      ProblemDefinitionParameter.Value.ProblemDefinitionChanged += ProblemDefinitionChanged;
       ProblemDefinitionParameter.Value.NameChanged += ProblemDefinitionHostOnNameChanged;
+    }
 …
+    }
     protected virtual void ProblemDefinitionHostOnInstanceChanged(object sender, EventArgs eventArgs) {
+    protected virtual void ProblemDefinitionChanged(object sender, EventArgs eventArgs) {
       Parameterize();
+    }
     protected virtual void Parameterize() {
       var instance = ProblemDefinitionParameter.Value.Instance;
       if (instance == null) return;
       Configuration configuration;
+      var definition = ProblemDefinitionParameter.Value;
+      if (definition == null) return;
+      Encoding encoding;
       try {
         configuration = instance.GetConfiguration();
+        encoding = definition.Encoding;
       } catch { return; }
       ConfigurationParameter.Value = configuration;
       Maximization.Value = instance.IsMaximizationProblem;
       Evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      EncodingParameter.Value = encoding;
+      Maximization.Value = definition.IsMaximizationProblem;
+      Evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
       Evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
       foreach (var evalOp in Operators.OfType<ISingleObjectiveProgrammableProblemEvaluator>()) {
         evalOp.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+        evalOp.EncodingParameter.ActualName = EncodingParameter.Name;
         evalOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
       foreach (var analyzeOp in Operators.OfType<ISingleObjectiveProgrammableProblemAnalyzer>()) {
         analyzeOp.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+        analyzeOp.EncodingParameter.ActualName = EncodingParameter.Name;
         analyzeOp.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
         analyzeOp.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
+      var solutionCreators = UpdateDynamicConfigurationParameters(configuration);
+      if (solutionCreators.Count == 1) {
+        Operators.RemoveAll(x => x is ParameterVectorCrossover
+                              || x is ParameterVectorManipulator);
+        UpdateSingleVectorEncodingOperators(solutionCreators, configuration);
+      foreach (var param in DynamicEncodingParameters)
+        if (Parameters.Contains(param)) Parameters.Remove(param);
+      DynamicEncodingParameters.Clear();
+      var creator = ConfigureCreator(encoding);
+      foreach (var param in DynamicEncodingParameters) {
+        param.Hidden = true;
+        Parameters.Add(param);
+      }
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        ConfigureMultiVectorEncodingOperators((MultiEncodingCreator)creator, multiEncoding);
       } else {
         UpdateMultiVectorEncodingOperators(solutionCreators, configuration);
+        ConfigureSingleEncodingOperators(creator, encoding);
+      }
       UpdateImprovementOperators();
 …
+    }
+    protected virtual List<ISolutionCreator> UpdateDynamicConfigurationParameters(Configuration configuration) {
+      foreach (var param in DynamicConfigurationParameters)
+        if (Parameters.Contains(param)) Parameters.Remove(param);
+      DynamicConfigurationParameters.Clear();
+      var solutionCreators = new List<ISolutionCreator>();
+      foreach (var param in configuration.Parameters) {
+        #region Configure BinaryVector Creator
+        var binConfig = param.Value as BinaryParameterConfiguration;
+        if (binConfig != null) {
+          var p = new ValueParameter<IntValue>(param.Key + "Length", binConfig.Length);
+          DynamicConfigurationParameters.Add(p);
+          var creator = new RandomBinaryVectorCreator();
+          creator.BinaryVectorParameter.ActualName = param.Key;
+          creator.LengthParameter.ActualName = p.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure IntegerVector Creator
+        var intConfig = param.Value as IntegerParameterConfiguration;
+        if (intConfig != null) {
+          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 = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.BoundsParameter.ActualName = b.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure RealVector Creator
+        var realConfig = param.Value as RealParameterConfiguration;
+        if (realConfig != null) {
+          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 = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.BoundsParameter.ActualName = b.Name;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+        #region Configure Permutation Creator
+        var permConfig = param.Value as PermutationParameterConfiguration;
+        if (permConfig != null) {
+          var l = new ValueParameter<IntValue>(param.Key + "Length", permConfig.Length);
+          DynamicConfigurationParameters.Add(l);
+          var creator = new RandomPermutationCreator();
+          creator.PermutationParameter.ActualName = param.Key;
+          creator.LengthParameter.ActualName = l.Name;
+          creator.PermutationTypeParameter.Value = permConfig.Type;
+          solutionCreators.Add(creator);
+        }
+        #endregion
+      }
+      foreach (var param in DynamicConfigurationParameters) {
+        param.Hidden = true;
+        Parameters.Add(param);
+      }
+      return solutionCreators;
+    }
+    protected virtual void UpdateSingleVectorEncodingOperators(List<ISolutionCreator> solutionCreators, Configuration configuration) {
+      var newCreator = solutionCreators.Single();
+    protected virtual ISolutionCreator ConfigureCreator(Encoding encoding) {
+      #region Configure MultiEncoding Creator
+      var multiEncoding = encoding as MultiEncoding;
+      if (multiEncoding != null) {
+        var creator = new MultiEncodingCreator();
+        foreach (var enc in multiEncoding.Encodings) {
+          if (enc is MultiEncoding) throw new InvalidOperationException("MultiEncoding within a MultiEncoding is not supported.");
+          creator.Operators.Add(ConfigureCreator(enc));
+        }
+        return creator;
+      }
+      #endregion
+      #region Configure BinaryVector Creator
+      var binEnc = encoding as BinaryEncoding;
+      if (binEnc != null) {
+        var p = new ValueParameter<IntValue>(binEnc.Name + "Length", binEnc.Length);
+        DynamicEncodingParameters.Add(p);
+        var creator = new RandomBinaryVectorCreator();
+        creator.BinaryVectorParameter.ActualName = binEnc.Name;
+        creator.LengthParameter.ActualName = p.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      var intEnc = encoding as IntegerEncoding;
+      if (intEnc != null) {
+        var l = new ValueParameter<IntValue>(intEnc.Name + "Length", intEnc.Length);
+        var b = new ValueParameter<IntMatrix>(intEnc.Name + "Bounds", intEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+        var creator = new UniformRandomIntegerVectorCreator();
+        creator.IntegerVectorParameter.ActualName = intEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure RealVector Creator
+      var realEnc = encoding as RealEncoding;
+      if (realEnc != null) {
+        var l = new ValueParameter<IntValue>(realEnc.Name + "Length", realEnc.Length);
+        var b = new ValueParameter<DoubleMatrix>(realEnc.Name + "Bounds", realEnc.Bounds);
+        DynamicEncodingParameters.Add(l);
+        DynamicEncodingParameters.Add(b);
+        var creator = new UniformRandomRealVectorCreator();
+        creator.RealVectorParameter.ActualName = realEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.BoundsParameter.ActualName = b.Name;
+        return creator;
+      }
+      #endregion
+      #region Configure Permutation Creator
+      var permEnc = encoding as PermutationEncoding;
+      if (permEnc != null) {
+        var l = new ValueParameter<IntValue>(permEnc.Name + "Length", permEnc.Length);
+        DynamicEncodingParameters.Add(l);
+        var creator = new RandomPermutationCreator();
+        creator.PermutationParameter.ActualName = permEnc.Name;
+        creator.LengthParameter.ActualName = l.Name;
+        creator.PermutationTypeParameter.Value = permEnc.Type;
+        return creator;
+      }
+      #endregion
+      throw new ArgumentException(string.Format("Encoding {0} is unknown.", encoding != null ? encoding.GetType().FullName : "(null)"));
+    }
+    protected virtual void ConfigureSingleEncodingOperators(ISolutionCreator newCreator, Encoding encoding) {
+      // remove all multiencoding operators
+      Operators.RemoveAll(x => x is MultiEncodingCrossover
+                            || x is MultiEncodingManipulator
+                            || x is MultiEncodingCreator);
       #region Configure Operators for BinaryVectorEncoding
       var binCreator = newCreator as IBinaryVectorCreator;
 …
         #region Wire BinaryVector Crossovers
+        Operators.RemoveAll(x => x is IBinaryVectorCrossover && ((IBinaryVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IBinaryVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorCrossover>(), new TypeEqualityComparer<IBinaryVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
 …
           xo.ParentsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IBinaryVectorCrossover>()));
         #endregion
         #region Wire BinaryVector Manipulators
+        Operators.RemoveAll(x => x is IBinaryVectorManipulator && ((IBinaryVectorManipulator)x).BinaryVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IBinaryVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorManipulator>(), new TypeEqualityComparer<IBinaryVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.BinaryVectorParameter.ActualName = binCreator.BinaryVectorParameter.ActualName;
           m.BinaryVectorParameter.Hidden = true;
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IBinaryVectorManipulator>()));
         #endregion
         #region Wire BinaryVector ShakingOperators
+        Operators.RemoveAll(x => x is IBinaryVectorMultiNeighborhoodShakingOperator && ((IBinaryVectorMultiNeighborhoodShakingOperator)x).BinaryVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IBinaryVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IBinaryVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.BinaryVectorParameter.ActualName = paramName;
           so.BinaryVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IBinaryVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire IntegerVector Crossovers
+        Operators.RemoveAll(x => x is IIntegerVectorCrossover && ((IIntegerVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IIntegerVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorCrossover>(), new TypeEqualityComparer<IIntegerVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
 …
+          }
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IIntegerVectorCrossover>()));
         #endregion
         #region Wire IntegerVector Manipulators
+        Operators.RemoveAll(x => x is IIntegerVectorManipulator && ((IIntegerVectorManipulator)x).IntegerVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IIntegerVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>(), new TypeEqualityComparer<IIntegerVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.IntegerVectorParameter.ActualName = intCreator.IntegerVectorParameter.ActualName;
 …
+          }
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IIntegerVectorManipulator>()));
         #region Wire IntegerVector StrategyParameters for SelfAdaptiveManipulators
+        Operators.RemoveAll(x => x is IStrategyParameterCreator && !(x is IIntegerVectorStdDevStrategyParameterCreator) || x is IIntegerVectorStdDevStrategyParameterCreator && ((IIntegerVectorStdDevStrategyParameterCreator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterManipulator && !(x is IIntegerVectorStdDevStrategyParameterManipulator) || x is IIntegerVectorStdDevStrategyParameterManipulator && ((IIntegerVectorStdDevStrategyParameterManipulator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterCrossover && !(x is IIntegerVectorStdDevStrategyParameterCrossover) || x is IIntegerVectorStdDevStrategyParameterCrossover && ((IIntegerVectorStdDevStrategyParameterCrossover)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        var strategyOperators = ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>().ToList();
+        if (!(configuration.Parameters.First().Value is IntegerParameterConfiguration)) throw new InvalidOperationException("Single-encoded problem with integervector creator that is not an integer-coded problem.");
+        var problemSize = ((IntegerParameterConfiguration)configuration.Parameters.First().Value).Length.Value;
+        var b = ((IntegerParameterConfiguration)configuration.Parameters.First().Value).Bounds;
+        var strategyOperators = Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IIntegerVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((IntegerEncoding)encoding).Length.Value;
+        var b = ((IntegerEncoding)encoding).Bounds;
         var bounds = new DoubleMatrix(b.Rows, b.Columns);
         for (var i = 0; i < bounds.Rows; i++) {
 …
+          }
+        }
         Operators.AddRange(strategyOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>()));
         #endregion
         #endregion
         #region Wire IntegerVector ShakingOperators
+        Operators.RemoveAll(x => x is IIntegerVectorMultiNeighborhoodShakingOperator && ((IIntegerVectorMultiNeighborhoodShakingOperator)x).IntegerVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IIntegerVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IIntegerVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.IntegerVectorParameter.ActualName = paramName;
           so.IntegerVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire RealVector Crossovers
+        Operators.RemoveAll(x => x is IRealVectorCrossover && ((IRealVectorCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IRealVectorCrossover>().ToList();
+        var crossovers = Operators.OfType<IRealVectorCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorCrossover>(), new TypeEqualityComparer<IRealVectorCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = paramName;
 …
           xo.BoundsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IRealVectorCrossover>()));
         #endregion
         #region Wire RealVector Manipulators
+        Operators.RemoveAll(x => x is IRealVectorManipulator && ((IRealVectorManipulator)x).RealVectorParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IRealVectorManipulator>().ToList();
+        var manipulators = Operators.OfType<IRealVectorManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorManipulator>(), new TypeEqualityComparer<IRealVectorManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.RealVectorParameter.ActualName = paramName;
 …
+          }
+        }
         Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(manipulators.Except(Operators.OfType<IRealVectorManipulator>()));
         #region Wire RealVector Strategy Parameters for SelfAdaptiveManipulators
+        Operators.RemoveAll(x => x is IStrategyParameterCreator && !(x is IRealVectorStdDevStrategyParameterCreator) || x is IRealVectorStdDevStrategyParameterCreator && ((IRealVectorStdDevStrategyParameterCreator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterManipulator && !(x is IRealVectorStdDevStrategyParameterManipulator) || x is IRealVectorStdDevStrategyParameterManipulator && ((IRealVectorStdDevStrategyParameterManipulator)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        Operators.RemoveAll(x => x is IStrategyParameterCrossover && !(x is IRealVectorStdDevStrategyParameterCrossover) || x is IRealVectorStdDevStrategyParameterCrossover && ((IRealVectorStdDevStrategyParameterCrossover)x).StrategyParameterParameter.ActualName != paramName + "Strategy");
+        var strategyOperators = ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>().ToList();
+        if (!(configuration.Parameters.First().Value is RealParameterConfiguration)) throw new InvalidOperationException("Single-encoded problem with realvector creator that is not a real-coded problem.");
+        var problemSize = ((RealParameterConfiguration)configuration.Parameters.First().Value).Length.Value;
+        var bounds = (DoubleMatrix)((RealParameterConfiguration)configuration.Parameters.First().Value).Bounds.Clone();
+        var strategyOperators = Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorStdDevStrategyParameterOperator>(), new TypeEqualityComparer<IRealVectorStdDevStrategyParameterOperator>())
+          .ToList();
+        var problemSize = ((RealEncoding)encoding).Length.Value;
+        var bounds = (DoubleMatrix)((RealEncoding)encoding).Bounds.Clone();
         for (var i = 0; i < bounds.Rows; i++) {
           bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
 …
+          }
+        }
         Operators.AddRange(strategyOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(strategyOperators.Except(Operators.OfType<IRealVectorStdDevStrategyParameterOperator>()));
         #endregion
         #endregion
         #region Wire RealVector ParticleCreators
+        Operators.RemoveAll(x => x is IRealVectorParticleCreator && ((IRealVectorParticleCreator)x).RealVectorParameter.ActualName != paramName);
+        var particleCreators = ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>().ToList();
+        var particleCreators = Operators.OfType<IRealVectorParticleCreator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleCreator>(), new TypeEqualityComparer<IRealVectorParticleCreator>())
+          .ToList();
         foreach (var pc in particleCreators) {
           pc.RealVectorParameter.ActualName = paramName;
 …
           pc.ProblemSizeParameter.Hidden = true;
+        }
         Operators.AddRange(particleCreators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(particleCreators.Except(Operators.OfType<IRealVectorParticleCreator>()));
         #endregion
         #region Wire RealVector ParticleUpdaters
+        Operators.RemoveAll(x => x is IRealVectorParticleUpdater && ((IRealVectorParticleUpdater)x).RealVectorParameter.ActualName != paramName);
+        var particleUpdaters = ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>().ToList();
+        var particleUpdaters = Operators.OfType<IRealVectorParticleUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorParticleUpdater>(), new TypeEqualityComparer<IRealVectorParticleUpdater>())
+          .ToList();
         foreach (var pu in particleUpdaters) {
           pu.RealVectorParameter.ActualName = paramName;
 …
           pu.BoundsParameter.Hidden = true;
+        }
         Operators.AddRange(particleUpdaters.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(particleUpdaters.Except(Operators.OfType<IRealVectorParticleUpdater>()));
         #endregion
         #region Wire RealVector SwarmUpdaters
+        Operators.RemoveAll(x => x is IRealVectorSwarmUpdater && ((IRealVectorSwarmUpdater)x).RealVectorParameter.ActualName != paramName);
+        var swarmUpdaters = ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>().ToList();
+        var swarmUpdaters = Operators.OfType<IRealVectorSwarmUpdater>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorSwarmUpdater>(), new TypeEqualityComparer<IRealVectorSwarmUpdater>())
+          .ToList();
         foreach (var su in swarmUpdaters) {
           su.RealVectorParameter.ActualName = paramName;
 …
           su.MaximizationParameter.Hidden = true;
+        }
         Operators.AddRange(swarmUpdaters.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(swarmUpdaters.Except(Operators.OfType<IRealVectorSwarmUpdater>()));
         #endregion
         #region Wire RealVector ShakingOperators
+        Operators.RemoveAll(x => x is IRealVectorMultiNeighborhoodShakingOperator && ((IRealVectorMultiNeighborhoodShakingOperator)x).RealVectorParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>().ToList();
+        var shakingOperators = Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IRealVectorMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IRealVectorMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var so in shakingOperators) {
           so.RealVectorParameter.ActualName = paramName;
           so.RealVectorParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
         #region Wire Permutation Crossovers
+        Operators.RemoveAll(x => x is IPermutationCrossover && ((IPermutationCrossover)x).ChildParameter.ActualName != paramName);
+        var crossovers = ApplicationManager.Manager.GetInstances<IPermutationCrossover>().ToList();
+        var crossovers = Operators.OfType<IPermutationCrossover>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationCrossover>(), new TypeEqualityComparer<IPermutationCrossover>())
+          .ToList();
         foreach (var xo in crossovers) {
           xo.ChildParameter.ActualName = permCreator.PermutationParameter.ActualName;
 …
           xo.ParentsParameter.Hidden = true;
+        }
         Operators.AddRange(crossovers.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(crossovers.Except(Operators.OfType<IPermutationCrossover>()));
         #endregion
         #region Wire Permutation Manipulators
+        Operators.RemoveAll(x => x is IPermutationManipulator && ((IPermutationManipulator)x).PermutationParameter.ActualName != paramName);
+        var manipulators = ApplicationManager.Manager.GetInstances<IPermutationManipulator>().ToList();
+        var manipulators = Operators.OfType<IPermutationManipulator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationManipulator>(), new TypeEqualityComparer<IPermutationManipulator>())
+          .ToList();
         foreach (var m in manipulators) {
           m.PermutationParameter.ActualName = permCreator.PermutationParameter.ActualName;
           m.PermutationParameter.Hidden = true;
+        }
+        Operators.AddRange(manipulators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        #endregion
+        #region Wire ShakingOperators
+        Operators.RemoveAll(x => x is IPermutationMultiNeighborhoodShakingOperator && ((IPermutationMultiNeighborhoodShakingOperator)x).PermutationParameter.ActualName != paramName);
+        var shakingOperators = ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>().ToList();
+        Operators.AddRange(manipulators.Except(Operators.OfType<IPermutationManipulator>()));
+        #endregion
+        #region Wire Permutation ShakingOperators
+        var shakingOperators = Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()
+          .Union(ApplicationManager.Manager.GetInstances<IPermutationMultiNeighborhoodShakingOperator>(), new TypeEqualityComparer<IPermutationMultiNeighborhoodShakingOperator>())
+          .ToList();
         foreach (var op in shakingOperators) {
           op.PermutationParameter.ActualName = paramName;
           op.PermutationParameter.Hidden = true;
+        }
         Operators.AddRange(shakingOperators.Where(x => Operators.All(y => x.GetType() != y.GetType())));
+        Operators.AddRange(shakingOperators.Except(Operators.OfType<IPermutationMultiNeighborhoodShakingOperator>()));
         #endregion
       } else {
 …
+    }
+    protected virtual void UpdateMultiVectorEncodingOperators(List<ISolutionCreator> solutionCreators, Configuration configuration) {
+      var oldCreator = SolutionCreator as ParameterVectorCreater;
+      var newCreator = new ParameterVectorCreater();
+      #region Configure BinaryVector Creator
+      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);
+    protected virtual void ConfigureMultiVectorEncodingOperators(MultiEncodingCreator newCreator, MultiEncoding encoding) {
+      var newBinParams = new HashSet<string>(newCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+      var newIntParams = new HashSet<string>(newCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+      var newRealParams = new HashSet<string>(newCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+      var newPermParams = new HashSet<string>(newCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+      var oldCreator = SolutionCreator as MultiEncodingCreator;
+      if (oldCreator == null) SolutionCreator = newCreator;
+      else {
+        #region Configure BinaryVector Creator
+        var oldBinParams = new HashSet<string>(oldCreator.Operators.OfType<IBinaryVectorCreator>().Select(x => x.BinaryVectorParameter.ActualName));
+        foreach (var toAdd in newBinParams.Except(oldBinParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IBinaryVectorCreator>().Single(x => x.BinaryVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+          var op = oldCreator.Operators.OfType<IBinaryVectorCreator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure IntegerVector Creator
+      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);
+        #endregion
+        #region Configure IntegerVector Creator
+        var oldIntParams = new HashSet<string>(oldCreator.Operators.OfType<IIntegerVectorCreator>().Select(x => x.IntegerVectorParameter.ActualName));
+        foreach (var toAdd in newIntParams.Except(oldIntParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IIntegerVectorCreator>().Single(x => x.IntegerVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+          var op = oldCreator.Operators.OfType<IIntegerVectorCreator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure RealVector Creator
+      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);
+        #endregion
+        #region Configure RealVector Creator
+        var oldRealParams = new HashSet<string>(oldCreator.Operators.OfType<IRealVectorCreator>().Select(x => x.RealVectorParameter.ActualName));
+        foreach (var toAdd in newRealParams.Except(oldRealParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IRealVectorCreator>().Single(x => x.RealVectorParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+          var op = oldCreator.Operators.OfType<IRealVectorCreator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
           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);
+        }
+      }
+      #endregion
+      #region Configure Permutation Creator
+      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);
+        #endregion
+        #region Configure Permutation Creator
+        var oldPermParams = new HashSet<string>(oldCreator.Operators.OfType<IPermutationCreator>().Select(x => x.PermutationParameter.ActualName));
+        foreach (var toAdd in newPermParams.Except(oldPermParams)) {
+          oldCreator.Operators.Add(newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == toAdd));
+        }
+        foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+          var op = oldCreator.Operators.OfType<IPermutationCreator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
           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);
+        foreach (var intersect in newPermParams.Intersect(oldPermParams)) {
+          var oldPermCreator = oldCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
+          var newPermCreator = newCreator.Operators.OfType<IPermutationCreator>().Single(x => x.PermutationParameter.ActualName == intersect);
           oldPermCreator.PermutationTypeParameter.Value = newPermCreator.PermutationTypeParameter.Value;
+        }
+      } else {
+        // we will use the new creator
+        foreach (var permCreator in solutionCreators.OfType<IPermutationCreator>()) {
+          newCreator.Operators.Add(permCreator);
+        }
+      }
+      #endregion
+      if (oldCreator == null) SolutionCreator = newCreator;
+        #endregion
+      }
       // 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()) {
+      if (Operators.OfType<MultiEncodingCrossover>().Any() && Operators.OfType<MultiEncodingManipulator>().Any()) {
         #region Update existing multi-vector encoding
         #region Update ParameterVector Crossover ...
         foreach (var oldXo in Operators.OfType<ParameterVectorCrossover>()) {
+        foreach (var oldXo in Operators.OfType<MultiEncodingCrossover>()) {
           #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldXo.Operators.OfType<IBinaryVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultBinaryCrossover(toAdd, encoding));
           foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IBinaryVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldXo.Operators.OfType<IIntegerVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultIntegerCrossover(toAdd, encoding));
           foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldXo.Operators.OfType<IIntegerVectorCrossover>()
+                .SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IIntegerVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldXo.Operators.OfType<IRealVectorCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultRealCrossover(toAdd, encoding));
           foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IRealVectorCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
           #endregion
           #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldXo.Operators.OfType<IPermutationCrossover>()
+            .Select(x => x.ChildParameter.ActualName));
+          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));
+            oldXo.Operators.Add(GetDefaultPermutationCrossover(toAdd, encoding));
           foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
+            var op = oldXo.Operators.OfType<IPermutationCrossover>().SingleOrDefault(x => x.ChildParameter.ActualName == toRemove);
             if (op != null) oldXo.Operators.Remove(op);
+          }
 …
         #endregion
         #region Update ParameterVector Manipulator ...
         foreach (var oldM in Operators.OfType<ParameterVectorManipulator>()) {
+        foreach (var oldM in Operators.OfType<MultiEncodingManipulator>()) {
           #region ... for binary parameters
+          var oldBinParams = new HashSet<string>(oldM.Operators.OfType<IBinaryVectorManipulator>()
+            .Select(x => x.BinaryVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultBinaryManipulator(toAdd, encoding));
           foreach (var toRemove in oldBinParams.Except(newBinParams)) {
+            var op =
+              oldM.Operators.OfType<IBinaryVectorManipulator>()
+                .SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IBinaryVectorManipulator>().SingleOrDefault(x => x.BinaryVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for integer parameters
+          var oldIntParams = new HashSet<string>(oldM.Operators.OfType<IIntegerVectorManipulator>()
+            .Select(x => x.IntegerVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultIntegerManipulator(toAdd, encoding));
           foreach (var toRemove in oldIntParams.Except(newIntParams)) {
+            var op =
+              oldM.Operators.OfType<IIntegerVectorManipulator>()
+                .SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IIntegerVectorManipulator>().SingleOrDefault(x => x.IntegerVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for real parameters
+          var oldRealParams = new HashSet<string>(oldM.Operators.OfType<IRealVectorManipulator>()
+            .Select(x => x.RealVectorParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultRealManipulator(toAdd, encoding));
           foreach (var toRemove in oldRealParams.Except(newRealParams)) {
+            var op =
+              oldM.Operators.OfType<IRealVectorManipulator>()
+                .SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IRealVectorManipulator>().SingleOrDefault(x => x.RealVectorParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
           #endregion
           #region ... for permutation parameters
+          var oldPermParams = new HashSet<string>(oldM.Operators.OfType<IPermutationManipulator>()
+            .Select(x => x.PermutationParameter.ActualName));
+          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));
+            oldM.Operators.Add(GetDefaultPermutationManipulator(toAdd, encoding));
           foreach (var toRemove in oldPermParams.Except(newPermParams)) {
+            var op =
+              oldM.Operators.OfType<IPermutationManipulator>()
+                .SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
+            var op = oldM.Operators.OfType<IPermutationManipulator>().SingleOrDefault(x => x.PermutationParameter.ActualName == toRemove);
             if (op != null) oldM.Operators.Remove(op);
+          }
 …
         Operators.RemoveAll(x => x is IMultiNeighborhoodShakingOperator);
         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));
+        var crossover = new MultiEncodingCrossover();
+        var manipulator = new MultiEncodingManipulator();
+        foreach (var enc in encoding.Encodings) {
+          if (enc is BinaryEncoding) {
+            crossover.Operators.Add(GetDefaultBinaryCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultBinaryManipulator(enc.Name, encoding));
             continue;
+          }
           var intConfig = param.Value as IntegerParameterConfiguration;
+          var intConfig = enc as IntegerEncoding;
           if (intConfig != null) {
             crossover.Operators.Add(GetDefaultIntegerCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultIntegerManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultIntegerCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultIntegerManipulator(enc.Name, encoding));
             continue;
+          }
           var realConfig = param.Value as RealParameterConfiguration;
+          var realConfig = enc as RealEncoding;
           if (realConfig != null) {
             crossover.Operators.Add(GetDefaultRealCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultRealManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultRealCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultRealManipulator(enc.Name, encoding));
             continue;
+          }
           var permConfig = param.Value as PermutationParameterConfiguration;
+          var permConfig = enc as PermutationEncoding;
           if (permConfig != null) {
             crossover.Operators.Add(GetDefaultPermutationCrossover(param.Key, configuration));
             manipulator.Operators.Add(GetDefaultPermutationManipulator(param.Key, configuration));
+            crossover.Operators.Add(GetDefaultPermutationCrossover(enc.Name, encoding));
+            manipulator.Operators.Add(GetDefaultPermutationManipulator(enc.Name, encoding));
             continue;
+          }
           throw new InvalidOperationException("Unknown type for parameter " + param.Key);
+          throw new InvalidOperationException("Unknown type for parameter " + enc.Name);
+        }
         Operators.Add(crossover);
 …
     protected virtual void UpdateImprovementOperators() {
       if (!Operators.Any(x => x is SingleObjectiveParameterVectorImprover))
         Operators.Add(new SingleObjectiveParameterVectorImprover());
       foreach (var improver in Operators.OfType<SingleObjectiveParameterVectorImprover>()) {
         improver.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      if (!Operators.Any(x => x is SingleObjectiveImprover))
+        Operators.Add(new SingleObjectiveImprover());
+      foreach (var improver in Operators.OfType<SingleObjectiveImprover>()) {
+        improver.EncodingParameter.ActualName = EncodingParameter.Name;
         improver.MaximizationParameter.ActualName = MaximizationParameter.Name;
         improver.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
 …
     protected virtual void UpdateMoveOperators() {
       if (!Operators.Any(x => x is ParameterVectorMoveGenerator))
         Operators.Add(new ParameterVectorMoveGenerator());
       if (!Operators.Any(x => x is ParameterVectorMoveEvaluator))
         Operators.Add(new ParameterVectorMoveEvaluator());
       if (!Operators.Any(x => x is ParameterVectorMoveMaker))
         Operators.Add(new ParameterVectorMoveMaker());
       foreach (var generator in Operators.OfType<ParameterVectorMoveGenerator>()) {
         generator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      if (!Operators.Any(x => x is SingleObjectiveMoveGenerator))
+        Operators.Add(new SingleObjectiveMoveGenerator());
+      if (!Operators.Any(x => x is SingleObjectiveMoveEvaluator))
+        Operators.Add(new SingleObjectiveMoveEvaluator());
+      if (!Operators.Any(x => x is SingleObjectiveMoveMaker))
+        Operators.Add(new SingleObjectiveMoveMaker());
+      foreach (var generator in Operators.OfType<SingleObjectiveMoveGenerator>()) {
+        generator.EncodingParameter.ActualName = EncodingParameter.Name;
         generator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
       foreach (var evaluator in Operators.OfType<ParameterVectorMoveEvaluator>()) {
         evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      foreach (var evaluator in Operators.OfType<SingleObjectiveMoveEvaluator>()) {
+        evaluator.EncodingParameter.ActualName = EncodingParameter.Name;
         evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         evaluator.ProblemDefinitionParameter.ActualName = ProblemDefinitionParameter.Name;
+      }
       foreach (var maker in Operators.OfType<ParameterVectorMoveMaker>()) {
         maker.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
         maker.MoveQualityParameter.ActualName = Operators.OfType<ParameterVectorMoveEvaluator>().First().MoveQualityParameter.ActualName;
+      foreach (var maker in Operators.OfType<SingleObjectiveMoveMaker>()) {
+        maker.EncodingParameter.ActualName = EncodingParameter.Name;
+        maker.MoveQualityParameter.ActualName = Operators.OfType<SingleObjectiveMoveEvaluator>().First().MoveQualityParameter.ActualName;
         maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      }
 …
     #region GetDefaultOperators for Crossovers and Manipulators
     // ReSharper disable RedundantNameQualifier
     protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, Configuration config) {
       var binConfig = (BinaryParameterConfiguration)config.Parameters[paramName];
+    protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, MultiEncoding config) {
+      var binConfig = (BinaryEncoding)config.Encodings[paramName];
       IBinaryVectorCrossover binXo;
       if (binConfig.Length.Value > 3) binXo = new Encodings.BinaryVectorEncoding.SinglePointCrossover();
 …
+    }
     protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, Configuration config) {
+    protected virtual IBinaryVectorManipulator GetDefaultBinaryManipulator(string paramName, MultiEncoding config) {
       var binM = new Encodings.BinaryVectorEncoding.SomePositionsBitflipManipulator();
       binM.BinaryVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, Configuration config) {
+    protected virtual IIntegerVectorCrossover GetDefaultIntegerCrossover(string paramName, MultiEncoding config) {
       var intXo = new Encodings.IntegerVectorEncoding.RoundedBlendAlphaBetaCrossover();
       intXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, Configuration configuration) {
+    protected virtual IIntegerVectorManipulator GetDefaultIntegerManipulator(string paramName, MultiEncoding configuration) {
       var intM = new Encodings.IntegerVectorEncoding.UniformSomePositionsManipulator();
       intM.IntegerVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, Configuration configuration) {
+    protected virtual IRealVectorCrossover GetDefaultRealCrossover(string paramName, MultiEncoding configuration) {
       var realXo = new Encodings.RealVectorEncoding.BlendAlphaBetaCrossover();
       realXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, Configuration configuration) {
+    protected virtual IRealVectorManipulator GetDefaultRealManipulator(string paramName, MultiEncoding configuration) {
       var realM = new Encodings.RealVectorEncoding.BreederGeneticAlgorithmManipulator();
       realM.RealVectorParameter.ActualName = paramName;
 …
+    }
     protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, Configuration configuration) {
+    protected virtual IPermutationCrossover GetDefaultPermutationCrossover(string paramName, MultiEncoding configuration) {
       var permXo = new Encodings.PermutationEncoding.PartiallyMatchedCrossover();
       permXo.ChildParameter.ActualName = paramName;
 …
+    }
     protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, Configuration configuration) {
+    protected virtual IPermutationManipulator GetDefaultPermutationManipulator(string paramName, MultiEncoding configuration) {
       var permM = new Encodings.PermutationEncoding.Swap2Manipulator();
       permM.PermutationParameter.ActualName = paramName;

Context Navigation

Legend:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable.Views/3.3/ProblemDefinitionScriptView.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Helper.cs

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

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProblemDefinition.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs

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

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

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinition.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveAnalyzer.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/MultiObjectiveEvaluator.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveAnalyzer.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Operators/SingleObjectiveEvaluator.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/ProblemDefinition.cs

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinition.cs

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

Download in other formats: