Changeset 11559 for branches/ProgrammableProblem/HeuristicLab.Problems.Programmable

Timestamp:

11/20/14 15:12:27 (10 years ago)

Author:

mkommend

Message:

#2174: Adapted IEncoding and Encoding base class.

Location:

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3

Files:

• Encodings/BinaryEncoding.cs (modified) (4 diffs)
• Encodings/Encoding.cs (modified) (2 diffs)
• Encodings/IntegerEncoding.cs (modified) (2 diffs)
• Encodings/MultiEncoding.cs (modified) (2 diffs)
• Encodings/PermutationEncoding.cs (modified) (1 diff)
• Encodings/RealEncoding.cs (modified) (11 diffs)
• Helper.cs (modified) (1 diff)
• Interfaces/IEncoding.cs (modified) (2 diffs)
• Interfaces/IMultiObjectiveProgrammableProblemAnalyzer.cs (modified) (1 diff)
• Interfaces/IMultiObjectiveProgrammableProblemEvaluator.cs (modified) (1 diff)
• Interfaces/ISingleObjectiveProgrammableProblemAnalyzer.cs (modified) (1 diff)
• Interfaces/ISingleObjectiveProgrammableProblemEvaluator.cs (modified) (1 diff)
• MultiObjectiveProblemDefinition.cs (modified) (1 diff)
• Operators/MultiObjectiveAnalyzer.cs (modified) (2 diffs)
• Operators/MultiObjectiveEvaluator.cs (modified) (2 diffs)
• Operators/SingleObjectiveAnalyzer.cs (modified) (2 diffs)
• Operators/SingleObjectiveEvaluator.cs (modified) (2 diffs)
• Operators/SingleObjectiveImprover.cs (modified) (2 diffs)
• Operators/SingleObjectiveMoveEvaluator.cs (modified) (2 diffs)
• Operators/SingleObjectiveMoveGenerator.cs (modified) (2 diffs)
• Operators/SingleObjectiveMoveMaker.cs (modified) (2 diffs)
• SingleObjectiveProblemDefinition.cs (modified) (1 diff)

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/BinaryEncoding.cs

@@ -35 +35 @@
   [Item("BinaryEncoding", "Describes a binary vector encoding.")]
   [StorableClass]
-  public sealed class BinaryEncoding : Encoding {
+  public sealed class BinaryEncoding : Encoding<IBinaryVectorCreator> {
     #region Encoding Parameters
     [Storable]
@@ -53 +53 @@
     #endregion
 
-    private List<IOperator> encodingOperators = new List<IOperator>();
-    [Storable]
-    public override IEnumerable<IOperator> Operators {
-      get { return encodingOperators; }
-      protected set { encodingOperators = new List<IOperator>(value); }
-    }
-
-    public override ISolutionCreator DefaultSolutionCreator {
-      get { return Operators.OfType<RandomBinaryVectorCreator>().First(); }
-    }
-
     public int Length {
       get { return LengthParameter.Value.Value; }
@@ -80 +69 @@
       : base(original, cloner) {
       lengthParameter = cloner.Clone(original.lengthParameter);
-      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
       RegisterParameterEvents();
     }
@@ -123 +111 @@
     #endregion
 
-    public void ConfigureOperators(IEnumerable<IOperator> operators) {
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
       ConfigureCreators(operators.OfType<IBinaryVectorCreator>());
       ConfigureCrossovers(operators.OfType<IBinaryVectorCrossover>());

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/Encoding.cs

@@ -31 +31 @@
   [Item("Encoding", "Base class for describing different encodings.")]
   [StorableClass]
-  public abstract class Encoding : NamedItem, IEncoding {
+  public abstract class Encoding<T> : NamedItem, IEncoding
+    where T : class,ISolutionCreator {
     public override sealed bool CanChangeName {
       get { return false; }
@@ -40 +41 @@
     }
 
-    public virtual IEnumerable<IOperator> Operators {
-      get { return Enumerable.Empty<IOperator>(); }
-      protected set { }
+    protected List<IOperator> encodingOperators = new List<IOperator>();
+    [Storable]
+    public IEnumerable<IOperator> Operators {
+      get { return encodingOperators; }
+      protected set { encodingOperators = new List<IOperator>(value); }
     }
 
-    public virtual ISolutionCreator DefaultSolutionCreator {
+
+    ISolutionCreator IEncoding.DefaultSolutionCreator { get { return DefaultSolutionCreator; } }
+    public virtual T DefaultSolutionCreator {
       get { return null; }
+    }
+
+
+    ISolutionCreator IEncoding.SolutionCreator {
+      get { return SolutionCreator; }
+      set {
+        if (!(value is T)) throw new ArgumentException("???");
+        SolutionCreator = (T)value;
+      }
+    }
+    private T solutionCreator;
+    public T SolutionCreator {
+      get {
+        if (solutionCreator == null) return DefaultSolutionCreator;
+        return solutionCreator;
+      }
+      set {
+        if (value == null) throw new ArgumentNullException("SolutionCreator must not be null.");
+        if (solutionCreator == value) return;
+        solutionCreator = value;
+        OnSolutionCreatorChanged();
+      }
     }
 
     [StorableConstructor]
     protected Encoding(bool deserializing) : base(deserializing) { }
-    protected Encoding(Encoding original, Cloner cloner)
-      : base(original, cloner) { }
+
+    protected Encoding(Encoding<T> original, Cloner cloner)
+      : base(original, cloner) {
+      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
+      solutionCreator = cloner.Clone(original.solutionCreator);
+    }
     protected Encoding(string name) : base(name) { }
+
+
+
+    public void ConfigureOperator(IOperator @operator) {
+      ConfigureOperators(new[] { @operator });
+    }
+    public virtual void ConfigureOperators(IEnumerable<IOperator> operators) {
+
+    }
+
+    protected virtual void OnSolutionCreatorChanged() {
+      ConfigureOperator(SolutionCreator);
+    }
+
 
     public event EventHandler ParameterConfigurationChanged;

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/IntegerEncoding.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31 +32 @@
   [Item("IntegerEncoding", "Describes an integer vector encoding.")]
   [StorableClass]
-  public class IntegerEncoding : Encoding {
+  public class IntegerEncoding : Encoding<IIntegerVectorCreator> {
     [Storable]
     private IntValue length;

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/MultiEncoding.cs

@@ -30 +30 @@
   [Item("MultiEncoding", "Describes a combined encoding consisting of multiple simpler encodings.")]
   [StorableClass]
-  public class MultiEncoding : Encoding {
+  public class MultiEncoding : Encoding<MultiEncodingCreator> {
     [Storable]
-    public KeyedItemCollection<string, Encoding> Encodings { get; protected set; }
+    public KeyedItemCollection<string, IEncoding> Encodings { get; protected set; }
 
     [StorableConstructor]
@@ -42 +42 @@
     public MultiEncoding()
       : base("MultiEncoding") {
-      Encodings = new NamedItemCollection<Encoding>();
+      Encodings = new NamedItemCollection<IEncoding>();
     }
 

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/PermutationEncoding.cs

@@ -29 +29 @@
   [Item("PermutationEncoding", "Describes a permutation encoding.")]
   [StorableClass]
-  public class PermutationEncoding : Encoding {
+  public class PermutationEncoding : Encoding<IPermutationCreator> {
     [Storable]
     private IntValue length;

branches/ProgrammableProblem/HeuristicLab.Problems.Programmable/3.3/Encodings/RealEncoding.cs

@@ -21 +21 @@
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -38 +35 @@
   [Item("RealEncoding", "Describes a real vector encoding.")]
   [StorableClass]
-  public sealed class RealEncoding : Encoding {
+  public sealed class RealEncoding : Encoding<IRealVectorCreator> {
     #region Encoding Parameters
     [Storable]
@@ -69 +66 @@
     #endregion
 
-    private List<IOperator> encodingOperators = new List<IOperator>();
-    [Storable]
-    public override IEnumerable<IOperator> Operators {
-      get { return encodingOperators; }
-      protected set { encodingOperators = new List<IOperator>(value); }
-    }
-
-    public override ISolutionCreator DefaultSolutionCreator {
-      get { return Operators.OfType<UniformRandomRealVectorCreator>().First(); }
-    }
-
     public int Length {
       get { return LengthParameter.Value.Value; }
@@ -88 +74 @@
       set { BoundsParameter.Value = value; }
     }
-
-
 
     [StorableConstructor]
@@ -104 +88 @@
       lengthParameter = cloner.Clone(original.lengthParameter);
       boundsParameter = cloner.Clone(original.boundsParameter);
-      encodingOperators = original.Operators.Select(cloner.Clone).ToList();
       RegisterParameterEvents();
     }
-
-
 
     public RealEncoding(string name, int length, double min, double max)
@@ -149 +130 @@
       ConfigureOperators(Operators);
     }
+
     private void RegisterParameterEvents() {
       RegisterLengthParameterEvents();
@@ -166 +148 @@
     static RealEncoding() {
       encodingSpecificOperatorTypes = new List<Type>() {
-        typeof (IRealVectorOperator),
-        typeof (IRealVectorCreator),
-        typeof (IRealVectorCrossover),
-        typeof (IRealVectorManipulator),
-        typeof (IRealVectorStdDevStrategyParameterOperator),
-        typeof (IRealVectorSwarmUpdater),
-        typeof (IRealVectorParticleCreator),
-        typeof (IRealVectorParticleUpdater),
-        typeof (IRealVectorMultiNeighborhoodShakingOperator),
-        typeof (IRealVectorBoundsChecker),
-        typeof (IRealVectorMoveOperator),
-        typeof (IRealVectorMoveGenerator)
-      };
+  typeof (IRealVectorOperator),
+  typeof (IRealVectorCreator),
+  typeof (IRealVectorCrossover),
+  typeof (IRealVectorManipulator),
+  typeof (IRealVectorStdDevStrategyParameterOperator),
+  typeof (IRealVectorSwarmUpdater),
+  typeof (IRealVectorParticleCreator),
+  typeof (IRealVectorParticleUpdater),
+  typeof (IRealVectorMultiNeighborhoodShakingOperator),
+  typeof (IRealVectorBoundsChecker),
+  typeof (IRealVectorMoveOperator),
+  typeof (IRealVectorMoveGenerator)
+  };
     }
     private void DiscoverOperators() {
-      var pluginDescription = ApplicationManager.Manager.GetDeclaringPlugin(typeof(IRealVectorOperator));
-      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, pluginDescription, true, false, false);
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, true, false, false);
       var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
       var newOperators = operators.Except(encodingOperators, new TypeEqualityComparer<IOperator>()).ToList();
@@ -188 +169 @@
       ConfigureOperators(newOperators);
       encodingOperators.AddRange(newOperators);
+
+      foreach (var strategyVectorCreator in Operators.OfType<IRealVectorStdDevStrategyParameterCreator>())
+        strategyVectorCreator.BoundsParameter.ValueChanged += strategyVectorCreator_BoundsParameter_ValueChanged;
     }
     #endregion
 
-    public void ConfigureOperators(IEnumerable<IOperator> operators) {
+
+    private void strategyVectorCreator_BoundsParameter_ValueChanged(object sender, EventArgs e) {
+      var boundsParameter = (IValueLookupParameter<DoubleMatrix>)sender;
+      if (boundsParameter.Value == null) return;
+      foreach (var strategyVectorManipulator in Operators.OfType<IRealVectorStdDevStrategyParameterManipulator>())
+        strategyVectorManipulator.BoundsParameter.Value = (DoubleMatrix)boundsParameter.Value.Clone();
+    }
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
       ConfigureCreators(operators.OfType<IRealVectorCreator>());
       ConfigureCrossovers(operators.OfType<IRealVectorCrossover>());
@@ -201 +193 @@
       ConfigureShakingOperators(operators.OfType<IRealVectorMultiNeighborhoodShakingOperator>());
       ConfigureBoundsCheckers(operators.OfType<IRealVectorBoundsChecker>());
+      ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
       ConfigureMoveOperators(operators.OfType<IRealVectorMoveOperator>());
-      ConfigureMoveGenerators(operators.OfType<IRealVectorMoveGenerator>());
+      ConfigureAdditiveMoveOperator(operators.OfType<IAdditiveRealVectorMoveOperator>());
     }
 
@@ -236 +229 @@
     }
     private void ConfigureStdDevStrategyParameterOperators(IEnumerable<IRealVectorStdDevStrategyParameterOperator> strategyOperators) {
-      var bounds = (DoubleMatrix)Bounds.Clone();
-      for (var i = 0; i < bounds.Rows; i++) {
-        bounds[i, 1] = 0.1 * (bounds[i, 1] - bounds[i, 0]);
+      var bounds = new DoubleMatrix(Bounds.Rows, Bounds.Columns);
+      for (var i = 0; i < Bounds.Rows; i++) {
         bounds[i, 0] = 0;
+        bounds[i, 1] = 0.1 * (Bounds[i, 1] - Bounds[i, 0]);
       }
       foreach (var s in strategyOperators) {
@@ -303 +296 @@
         moveGenerator.BoundsParameter.ActualName = BoundsParameter.Name;
     }
+
+    private void ConfigureAdditiveMoveOperator(IEnumerable<IAdditiveRealVectorMoveOperator> additiveMoveOperators) {
+      foreach (var additiveMoveOperator in additiveMoveOperators) {
+        additiveMoveOperator.AdditiveMoveParameter.ActualName = Name + "_AdditiveMove";
+      }
+    }
     #endregion
   }

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

@@ -30 +30 @@
 namespace HeuristicLab.Problems.Programmable {
   internal static class Helper {
-    internal static Individual Extract(IScope scope, Encoding encoding) {
+    internal static Individual Extract(IScope scope, IEncoding encoding) {
       Dictionary<string, BinaryVector> binDict = null;
       Dictionary<string, IntegerVector> intDict = null;

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

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Dynamic;
 using System.Linq;
 using System.Text;
@@ -30 +31 @@
   public interface IEncoding : INamedItem
   {
+    
     ISolutionCreator DefaultSolutionCreator { get; }
+    ISolutionCreator SolutionCreator { get; set; }
+
+
     IEnumerable<IValueParameter> Parameters { get; }
     IEnumerable<IOperator> Operators { get; }
     //event EventHandler ParameterConfigurationChanged;
+
+    void ConfigureOperator(IOperator @operator);
+    void ConfigureOperators(IEnumerable<IOperator> operators);    
   }
 }

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

@@ -27 +27 @@
   public interface IMultiObjectiveProgrammableProblemAnalyzer : IAnalyzer {
     ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
-    ILookupParameter<Encoding> EncodingParameter { get; }
+    ILookupParameter<IEncoding> EncodingParameter { get; }
     IScopeTreeLookupParameter<DoubleArray> QualitiesParameter { get; }
     ILookupParameter<ResultCollection> ResultsParameter { get; }

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

@@ -26 +26 @@
   public interface IMultiObjectiveProgrammableProblemEvaluator : IMultiObjectiveEvaluator {
     ILookupParameter<IMultiObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
-    ILookupParameter<Encoding> EncodingParameter { get; }
+    ILookupParameter<IEncoding> EncodingParameter { get; }
   }
 }

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

@@ -27 +27 @@
   public interface ISingleObjectiveProgrammableProblemAnalyzer : IAnalyzer {
     ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
-    ILookupParameter<Encoding> EncodingParameter { get; }
+    ILookupParameter<IEncoding> EncodingParameter { get; }
     IScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
     ILookupParameter<ResultCollection> ResultsParameter { get; }

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

@@ -26 +26 @@
   public interface ISingleObjectiveProgrammableProblemEvaluator : ISingleObjectiveEvaluator {
     ILookupParameter<ISingleObjectiveProblemDefinition> ProblemDefinitionParameter { get; }
-    ILookupParameter<Encoding> EncodingParameter { get; }
+    ILookupParameter<IEncoding> EncodingParameter { get; }
   }
 }

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

@@ -36 +36 @@
     protected MultiObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
     protected MultiObjectiveProblemDefinition(MultiObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
-    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, name, description) { }
+    protected MultiObjectiveProblemDefinition(IEncoding encoding) : this(encoding, "MultiObjectiveProblemDefinition", null) { }
+    protected MultiObjectiveProblemDefinition(IEncoding encoding, string name) : this(encoding, name, null) { }
+    protected MultiObjectiveProblemDefinition(IEncoding encoding, string name, string description) : base(encoding, name, description) { }
   }
 }

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

@@ -20 +20 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -38 +38 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("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."));

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

@@ -42 +42 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -56 +56 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
     }

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

@@ -20 +20 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -38 +38 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("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."));

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

@@ -42 +42 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -56 +56 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
     }

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

@@ -25 +25 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -55 +55 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
       Parameters.Add(new LookupParameter<BoolValue>("Maximization", "Whether the problem should be minimized or maximized."));

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

@@ -42 +42 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -60 +60 @@
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       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<IEncoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));

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

@@ -48 +48 @@
     }
 
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -60 +60 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to sample."));
       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<IEncoding>("Encoding", "An item that holds the problem's encoding."));
     }
 

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

@@ -33 +33 @@
   [StorableClass]
   public class SingleObjectiveMoveMaker : InstrumentedOperator, ISingleObjectiveMoveOperator, IMoveMaker {
-    public ILookupParameter<Encoding> EncodingParameter {
-      get { return (ILookupParameter<Encoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding> EncodingParameter {
+      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
     }
 
@@ -49 +49 @@
     protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveMoveMaker() {
-      Parameters.Add(new LookupParameter<Encoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
       Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));

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

@@ -36 +36 @@
     protected SingleObjectiveProblemDefinition(bool deserializing) : base(deserializing) { }
     protected SingleObjectiveProblemDefinition(SingleObjectiveProblemDefinition original, Cloner cloner) : base(original, cloner) { }
-    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, name, description) { }
+    protected SingleObjectiveProblemDefinition(IEncoding encoding) : this(encoding, "SingleObjectiveProblemDefinition", null) { }
+    protected SingleObjectiveProblemDefinition(IEncoding encoding, string name) : this(encoding, name, null) { }
+    protected SingleObjectiveProblemDefinition(IEncoding encoding, string name, string description) : base(encoding, name, description) { }
   }
 }