Index: /branches/ProblemRefactoring/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.4/CMAEvolutionStrategy.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.4/CMAEvolutionStrategy.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Algorithms.CMAEvolutionStrategy/3.4/CMAEvolutionStrategy.cs	(revision 13361)
@@ -63,9 +63,10 @@
 
     #region Problem Properties
+
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
-    }
-    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
-      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      get { return typeof(ISingleObjectiveProblem<RealVectorEncoding, RealVector>); }
+    }
+    public new ISingleObjectiveProblem<RealVectorEncoding, RealVector> Problem {
+      get { return (ISingleObjectiveProblem<RealVectorEncoding, RealVector>)base.Problem; }
       set { base.Problem = value; }
     }
@@ -378,10 +379,4 @@
     }
 
-    protected override void OnStarted() {
-      if (!(Problem.SolutionCreator is IRealVectorCreator))
-        throw new InvalidOperationException("Problems that do not use RealVectorEncoding cannot be solved by CMA-ES.");
-      base.OnStarted();
-    }
-
     #region Events
     protected override void OnProblemChanged() {
Index: /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 13361)
@@ -22,11 +22,8 @@
 
 using System;
-using HeuristicLab.Common;
+using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -34,6 +31,6 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  internal sealed class EvaluationTracker : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> {
-    private readonly ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem;
+  internal sealed class EvaluationTracker : ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> {
+    private readonly ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem;
 
     private int maxEvaluations;
@@ -60,24 +57,10 @@
     }
 
-    public new BinaryVectorEncoding Encoding {
+    public BinaryVectorEncoding Encoding {
       get { return problem.Encoding; }
     }
     #endregion
 
-    [StorableConstructor]
-    private EvaluationTracker(bool deserializing) : base(deserializing) { }
-    private EvaluationTracker(EvaluationTracker original, Cloner cloner)
-      : base(original, cloner) {
-      problem = cloner.Clone(original.problem);
-      maxEvaluations = original.maxEvaluations;
-      BestQuality = original.BestQuality;
-      Evaluations = original.Evaluations;
-      BestFoundOnEvaluation = original.BestFoundOnEvaluation;
-      BestSolution = cloner.Clone(BestSolution);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new EvaluationTracker(this, cloner);
-    }
-    public EvaluationTracker(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
+    public EvaluationTracker(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
       this.problem = problem;
       this.maxEvaluations = maxEvaluations;
@@ -86,10 +69,9 @@
       Evaluations = 0;
       BestFoundOnEvaluation = 0;
-
-      if (Parameters.ContainsKey("Maximization")) Parameters.Remove("Maximization");
-      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
     }
 
-    public override double Evaluate(BinaryVector vector, IRandom random) {
+
+
+    public double Evaluate(BinaryVector vector, IRandom random) {
       if (Evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
       Evaluations++;
@@ -103,5 +85,5 @@
     }
 
-    public override bool Maximization {
+    public bool Maximization {
       get {
         if (problem == null) return false;
@@ -110,8 +92,15 @@
     }
 
-    public override bool IsBetter(double quality, double bestQuality) {
+    public bool IsBetter(double quality, double bestQuality) {
       return problem.IsBetter(quality, bestQuality);
     }
 
+    public void Analyze(BinaryVector[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      problem.Analyze(individuals, qualities, results, random);
+    }
+
+    public IEnumerable<BinaryVector> GetNeighbors(BinaryVector individual, IRandom random) {
+      return problem.GetNeighbors(individual, random);
+    }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 13361)
@@ -49,9 +49,9 @@
 
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
+      get { return typeof(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -97,5 +97,5 @@
     }
     // In the GECCO paper, Section 2.1
-    public static double ImproveToLocalOptimum(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
+    public static double ImproveToLocalOptimum(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
       var tried = new HashSet<int>();
       do {
Index: /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 13361)
@@ -33,5 +33,5 @@
   public static class LinkageCrossover {
     // In the GECCO paper, Figure 3
-    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
+    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
       var options = Enumerable.Range(0, donors.Count).ToArray();
       foreach (var cluster in tree.Clusters) {
@@ -48,5 +48,5 @@
     }
 
-    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
+    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
       // keep track of which bits flipped to make the donation
       List<int> flipped = new List<int>();
Index: /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 13361)
@@ -45,7 +45,7 @@
       get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -182,5 +182,5 @@
       if (seen.Contains(solution)) return;
       if (level == pyramid.Count) {
-        pyramid.Add(new Population(tracker.Encoding.Length, random));
+        pyramid.Add(new Population(Problem.Encoding.Length, random));
       }
       var copied = (BinaryVector)solution.Clone();
@@ -192,5 +192,5 @@
     private double iterate() {
       // Create a random solution
-      BinaryVector solution = new BinaryVector(tracker.Encoding.Length);
+      BinaryVector solution = new BinaryVector(Problem.Encoding.Length);
       for (int i = 0; i < solution.Length; i++) {
         solution[i] = random.Next(2) == 1;
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/Interfaces/IRealVectorCreator.cs	(revision 13361)
@@ -28,5 +28,5 @@
   /// An interface which represents an operator for creating vectors of real-valued data.
   /// </summary>
-  public interface IRealVectorCreator : IRealVectorOperator, ISolutionCreator {
+  public interface IRealVectorCreator : IRealVectorOperator, ISolutionCreator<RealVector> {
     IValueLookupParameter<IntValue> LengthParameter { get; }
     IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 13361)
@@ -23,4 +23,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -28,5 +29,5 @@
   [StorableClass]
   [Item("RealVector", "Represents a vector of real values.")]
-  public class RealVector : DoubleArray {
+  public class RealVector : DoubleArray, ISolution {
     [StorableConstructor]
     protected RealVector(bool deserializing) : base(deserializing) { }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVectorEncoding.cs	(revision 13361)
@@ -34,5 +34,5 @@
   [Item("RealVectorEncoding", "Describes a real vector encoding.")]
   [StorableClass]
-  public sealed class RealVectorEncoding : Encoding<IRealVectorCreator> {
+  public sealed class RealVectorEncoding : Encoding<RealVector> {
     #region Encoding Parameters
     [Storable]
@@ -95,5 +95,5 @@
     public RealVectorEncoding(string name) : this(name, 10) { }
     public RealVectorEncoding(int length) : this("RealVector", length) { }
-    public RealVectorEncoding(string name, int length, double min = double.MinValue, double max = double.MaxValue)
+    public RealVectorEncoding(string name, int length, double min = -1000, double max = 1000)
       : base(name) {
       if (min >= max) throw new ArgumentException("min must be less than max", "min");
@@ -318,13 +318,3 @@
     #endregion
   }
-
-  public static class IndividualExtensionMethods {
-    public static RealVector RealVector(this Individual individual) {
-      var encoding = individual.GetEncoding<RealVectorEncoding>();
-      return individual.RealVector(encoding.Name);
-    }
-    public static RealVector RealVector(this Individual individual, string name) {
-      return (RealVector)individual[name];
-    }
-  }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 13361)
@@ -20,4 +20,5 @@
 #endregion
 
+
 namespace HeuristicLab.Optimization {
   public interface IProblemDefinition<TEncoding, TSolution>
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs	(revision 13361)
@@ -24,8 +24,8 @@
 
 namespace HeuristicLab.Optimization {
-  public interface ISingleObjectiveProblem<TEncoding, TSolution> : IProblem<TEncoding, TSolution>, ISingleObjectiveProblemDefinition<TEncoding, TSolution>, ISingleObjectiveHeuristicOptimizationProblem
+  public interface ISingleObjectiveProblem<TEncoding, TSolution> : IProblem<TEncoding, TSolution>, ISingleObjectiveHeuristicOptimizationProblem
     where TEncoding : class, IEncoding<TSolution>
     where TSolution : class, ISolution {
-    bool IsBetter(double quality, double bestQuality);
+
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13361)
@@ -31,4 +31,5 @@
     void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
     IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
+    bool IsBetter(double quality, double bestQuality);
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 13361)
@@ -29,7 +29,11 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class MultiObjectiveProblem<TEncoding, TSolution> : Problem<TEncoding, TSolution, MultiObjectiveEvaluator<TSolution>>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition<TEncoding, TSolution>
+  public abstract class MultiObjectiveProblem<TEncoding, TSolution> :
+    Problem<TEncoding, TSolution, MultiObjectiveEvaluator<TSolution>>,
+    IMultiObjectiveProblem<TEncoding, TSolution>,
+    IMultiObjectiveProblemDefinition<TEncoding, TSolution>
     where TEncoding : class, IEncoding<TSolution>
     where TSolution : class, ISolution {
+
     [StorableConstructor]
     protected MultiObjectiveProblem(bool deserializing) : base(deserializing) { }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13361)
@@ -30,5 +30,8 @@
 namespace HeuristicLab.Optimization {
   [StorableClass]
-  public abstract class SingleObjectiveProblem<TEncoding, TSolution> : Problem<TEncoding, TSolution, SingleObjectiveEvaluator<TSolution>>, ISingleObjectiveProblem<TEncoding, TSolution>
+  public abstract class SingleObjectiveProblem<TEncoding, TSolution> :
+    Problem<TEncoding, TSolution, SingleObjectiveEvaluator<TSolution>>,
+    ISingleObjectiveProblem<TEncoding, TSolution>,
+    ISingleObjectiveProblemDefinition<TEncoding, TSolution>
     where TEncoding : class, IEncoding<TSolution>
     where TSolution : class, ISolution {
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 13361)
@@ -123,4 +123,5 @@
     <Compile Include="BasicProblems\Individuals\MultiSolution.cs" />
     <Compile Include="BasicProblems\Interfaces\IMultiEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\IMultiObjectiveProblem.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblem.cs" />
     <Compile Include="BasicProblems\MultiEncoding.cs" />
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 13361)
@@ -36,5 +36,5 @@
   }
 
-  public interface IProblem<TEncoding, TSolution> : IHeuristicOptimizationProblem, IProblemDefinition<TEncoding, TSolution>
+  public interface IProblem<TEncoding, TSolution> : IHeuristicOptimizationProblem
     where TEncoding : class, IEncoding<TSolution>
     where TSolution : class, ISolution {
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 13361)
@@ -22,5 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Threading;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
@@ -63,4 +62,8 @@
     public abstract void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
     public abstract IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
+
+    public bool IsBetter(double quality, double bestQuality) {
+      return Maximization ? quality > bestQuality : quality < bestQuality;
+    }
     #endregion
   }
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 13361)
@@ -96,6 +96,5 @@
     </Compile>
     <Compile Include="ProblemDefinitionScriptException.cs" />
-    <Compile Include="MultiObjectiveProgrammableProblems.cs" />
-    <Compile Include="SingleObjectiveProgrammableProblems.cs" />
+    <Compile Include="ProgrammableProblemInstances.cs" />
     <Content Include="Templates\CompiledSingleObjectiveProblemDefinition_Template.cs" />
     <Content Include="Templates\CompiledMultiObjectiveProblemDefinition_Template.cs">
@@ -155,4 +154,8 @@
       <Name>HeuristicLab.Encodings.BinaryVectorEncoding-3.3</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.RealVectorEncoding\3.3\HeuristicLab.Encodings.RealVectorEncoding-3.3.csproj">
+      <Project>{bb6d334a-4bb6-4674-9883-31a6ebb32cab}</Project>
+      <Name>HeuristicLab.Encodings.RealVectorEncoding-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
       <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
Index: anches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblems.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblems.cs	(revision 13360)
+++ 	(revision )
@@ -1,160 +1,0 @@
-﻿#region License Information
-
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.BinaryVectorEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.Programmable {
-  [Item("Binary Vector Programmable Problem (multi-objective)", "Represents a binary vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveBinaryVectorProgrammableProblem : MultiObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
-
-    [StorableConstructor]
-    private MultiObjectiveBinaryVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveBinaryVectorProgrammableProblem(MultiObjectiveBinaryVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public MultiObjectiveBinaryVectorProgrammableProblem()
-      : base() {
-      var codeTemplate = ScriptTemplates.CompiledMultiObjectiveProblemDefinition_Template;
-      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "BinaryVector");
-      ProblemScript.Code = codeTemplate;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveBinaryVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Multi Solution Programmable Problem (multi-objective)", "Represents a multi solution multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
-
-    [StorableConstructor]
-    private MultiObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveMultiSolutionProgrammableProblem(MultiObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public MultiObjectiveMultiSolutionProgrammableProblem()
-      : base() {
-      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
-      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "MultiEncoding");
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "CombinedSolution");
-      ProblemScript.Code = codeTemplate;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveMultiSolutionProgrammableProblem(this, cloner);
-    }
-  }
-
-  //TODO
-  /*
-  [Item("Integer Vector Programmable Problem (multi-objective)", "Represents an integer vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveIntegerVectorProgrammableProblem : MultiObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
-
-    [StorableConstructor]
-    private MultiObjectiveIntegerVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveIntegerVectorProgrammableProblem(MultiObjectiveIntegerVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public MultiObjectiveIntegerVectorProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.IntegerVectorEncoding", "IntegerVectorEncoding", "IntegerVector")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveIntegerVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Real Vector Programmable Problem (multi-objective)", "Represents a real vector multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveRealVectorProgrammableProblem : MultiObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
-
-    [StorableConstructor]
-    private MultiObjectiveRealVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveRealVectorProgrammableProblem(MultiObjectiveRealVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public MultiObjectiveRealVectorProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.RealVectorEncoding", "RealVectorEncoding", "RealVector")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveRealVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Permutation Programmable Problem (multi-objective)", "Represents a permutation multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectivePermutationProgrammableProblem : MultiObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
-
-    [StorableConstructor]
-    private MultiObjectivePermutationProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectivePermutationProgrammableProblem(MultiObjectivePermutationProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public MultiObjectivePermutationProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.PermutationEncoding", "PermutationEncoding", "Permutation")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectivePermutationProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
-
-    [StorableConstructor]
-    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
-
-    [StorableConstructor]
-    private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public MultiObjectiveLinearLinkageProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
-    }
-  }*/
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemInstances.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemInstances.cs	(revision 13361)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProgrammableProblemInstances.cs	(revision 13361)
@@ -0,0 +1,305 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  #region single-objective
+  [Item("Binary Vector Programmable Problem (single-objective)", "Represents a binary vector single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class SingleObjectiveBinaryVectorProgrammableProblem : SingleObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
+
+    [StorableConstructor]
+    private SingleObjectiveBinaryVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveBinaryVectorProgrammableProblem(SingleObjectiveBinaryVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public SingleObjectiveBinaryVectorProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "BinaryVector");
+      ProblemScript.Code = codeTemplate;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveBinaryVectorProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Multi Solution Programmable Problem (single-objective)", "Represents a multi solution single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
+
+    [StorableConstructor]
+    private SingleObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveMultiSolutionProgrammableProblem(SingleObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public SingleObjectiveMultiSolutionProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "MultiEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "CombinedSolution");
+      ProblemScript.Code = codeTemplate;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveMultiSolutionProgrammableProblem(this, cloner);
+    }
+  }
+
+  //[Item("Integer Vector Programmable Problem (single-objective)", "Represents an integer vector single-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class SingleObjectiveIntegerVectorProgrammableProblem : SingleObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
+
+  //  [StorableConstructor]
+  //  private SingleObjectiveIntegerVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private SingleObjectiveIntegerVectorProgrammableProblem(SingleObjectiveIntegerVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public SingleObjectiveIntegerVectorProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.IntegerVectorEncoding", "IntegerVectorEncoding", "IntegerVector")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new SingleObjectiveIntegerVectorProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  [Item("Real Vector Programmable Problem (single-objective)", "Represents a real vector single-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class SingleObjectiveRealVectorProgrammableProblem : SingleObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
+
+    [StorableConstructor]
+    private SingleObjectiveRealVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private SingleObjectiveRealVectorProgrammableProblem(SingleObjectiveRealVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public SingleObjectiveRealVectorProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.RealVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "RealVectorEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "RealVector");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SingleObjectiveRealVectorProgrammableProblem(this, cloner);
+    }
+  }
+
+  //[Item("Permutation Programmable Problem (single-objective)", "Represents a permutation single-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class SingleObjectivePermutationProgrammableProblem : SingleObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
+
+  //  [StorableConstructor]
+  //  private SingleObjectivePermutationProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private SingleObjectivePermutationProgrammableProblem(SingleObjectivePermutationProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public SingleObjectivePermutationProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.PermutationEncoding", "PermutationEncoding", "Permutation")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new SingleObjectivePermutationProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  //[Item("Symbolic Expression Tree Programmable Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
+
+  //  [StorableConstructor]
+  //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  //[Item("Linear Linkage Programmable Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
+
+  //  [StorableConstructor]
+  //  private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public SingleObjectiveLinearLinkageProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
+  //  }
+  //}
+  #endregion
+
+  #region multi-objective
+  [Item("Binary Vector Programmable Problem (multi-objective)", "Represents a binary vector multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class MultiObjectiveBinaryVectorProgrammableProblem : MultiObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
+
+    [StorableConstructor]
+    private MultiObjectiveBinaryVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveBinaryVectorProgrammableProblem(MultiObjectiveBinaryVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public MultiObjectiveBinaryVectorProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledMultiObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "BinaryVector");
+      ProblemScript.Code = codeTemplate;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveBinaryVectorProgrammableProblem(this, cloner);
+    }
+  }
+
+  [Item("Multi Solution Programmable Problem (multi-objective)", "Represents a multi solution multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class MultiObjectiveMultiSolutionProgrammableProblem : MultiObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
+
+    [StorableConstructor]
+    private MultiObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveMultiSolutionProgrammableProblem(MultiObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public MultiObjectiveMultiSolutionProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "MultiEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "CombinedSolution");
+      ProblemScript.Code = codeTemplate;
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveMultiSolutionProgrammableProblem(this, cloner);
+    }
+  }
+
+  //[Item("Integer Vector Programmable Problem (multi-objective)", "Represents an integer vector multi-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class MultiObjectiveIntegerVectorProgrammableProblem : MultiObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
+
+  //  [StorableConstructor]
+  //  private MultiObjectiveIntegerVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private MultiObjectiveIntegerVectorProgrammableProblem(MultiObjectiveIntegerVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public MultiObjectiveIntegerVectorProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.IntegerVectorEncoding", "IntegerVectorEncoding", "IntegerVector")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new MultiObjectiveIntegerVectorProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  [Item("Real Vector Programmable Problem (multi-objective)", "Represents a real vector multi-objective problem that can be programmed with a script.")]
+  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  [StorableClass]
+  public sealed class MultiObjectiveRealVectorProgrammableProblem : MultiObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
+
+    [StorableConstructor]
+    private MultiObjectiveRealVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
+    private MultiObjectiveRealVectorProgrammableProblem(MultiObjectiveRealVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+
+    public MultiObjectiveRealVectorProgrammableProblem()
+      : base() {
+      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
+      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.RealVectorEncoding");
+      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "RealVectorEncoding");
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "RealVector");
+      ProblemScript.Code = codeTemplate;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiObjectiveRealVectorProgrammableProblem(this, cloner);
+    }
+  }
+
+  //[Item("Permutation Programmable Problem (multi-objective)", "Represents a permutation multi-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class MultiObjectivePermutationProgrammableProblem : MultiObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
+
+  //  [StorableConstructor]
+  //  private MultiObjectivePermutationProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private MultiObjectivePermutationProgrammableProblem(MultiObjectivePermutationProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public MultiObjectivePermutationProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.PermutationEncoding", "PermutationEncoding", "Permutation")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new MultiObjectivePermutationProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  //[Item("Symbolic Expression Tree Programmable Problem (multi-objective)", "Represents a symbolic expression tree multi-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class MultiObjectiveSymbolicExpressionTreeProgrammableProblem : MultiObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
+
+  //  [StorableConstructor]
+  //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private MultiObjectiveSymbolicExpressionTreeProgrammableProblem(MultiObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public MultiObjectiveSymbolicExpressionTreeProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new MultiObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
+  //  }
+  //}
+
+  //[Item("Linear Linkage Programmable Problem (multi-objective)", "Represents a linear linkage multi-objective problem that can be programmed with a script.")]
+  //[Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
+  //[StorableClass]
+  //public sealed class MultiObjectiveLinearLinkageProgrammableProblem : MultiObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
+
+  //  [StorableConstructor]
+  //  private MultiObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
+  //  private MultiObjectiveLinearLinkageProgrammableProblem(MultiObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
+  //  public MultiObjectiveLinearLinkageProgrammableProblem()
+  //    : base(string.Format(ScriptTemplates.CompiledMultiObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
+
+  //  public override IDeepCloneable Clone(Cloner cloner) {
+  //    return new MultiObjectiveLinearLinkageProgrammableProblem(this, cloner);
+  //  }
+  //}
+  #endregion
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 13361)
@@ -62,4 +62,8 @@
       return CompiledProblemDefinition.GetNeighbors(individual, random);
     }
+
+    bool ISingleObjectiveProblemDefinition<TEncoding, TSolution>.IsBetter(double quality, double bestQuality) {
+      return CompiledProblemDefinition.IsBetter(quality, bestQuality);
+    }
   }
 }
Index: anches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblems.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblems.cs	(revision 13360)
+++ 	(revision )
@@ -1,159 +1,0 @@
-﻿#region License Information
-
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#endregion
-
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.BinaryVectorEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.Programmable {
-  [Item("Binary Vector Programmable Problem (single-objective)", "Represents a binary vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveBinaryVectorProgrammableProblem : SingleObjectiveProgrammableProblem<BinaryVectorEncoding, BinaryVector> {
-
-    [StorableConstructor]
-    private SingleObjectiveBinaryVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveBinaryVectorProgrammableProblem(SingleObjectiveBinaryVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public SingleObjectiveBinaryVectorProgrammableProblem()
-      : base() {
-      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
-      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "BinaryVector");
-      ProblemScript.Code = codeTemplate;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveBinaryVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Multi Solution Programmable Problem (single-objective)", "Represents a multi solution single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveMultiSolutionProgrammableProblem : SingleObjectiveProgrammableProblem<MultiEncoding, CombinedSolution> {
-
-    [StorableConstructor]
-    private SingleObjectiveMultiSolutionProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveMultiSolutionProgrammableProblem(SingleObjectiveMultiSolutionProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-
-    public SingleObjectiveMultiSolutionProgrammableProblem()
-      : base() {
-      var codeTemplate = ScriptTemplates.CompiledSingleObjectiveProblemDefinition_Template;
-      codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, "HeuristicLab.Encodings.BinaryVectorEncoding");
-      codeTemplate = codeTemplate.Replace(ENCODING_CLASS, "MultiEncoding");
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, "CombinedSolution");
-      ProblemScript.Code = codeTemplate;
-    }
-
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMultiSolutionProgrammableProblem(this, cloner);
-    }
-  }
-  //TODO
-  /*
-  [Item("Integer Vector Programmable Problem (single-objective)", "Represents an integer vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveIntegerVectorProgrammableProblem : SingleObjectiveProgrammableProblem<IntegerVectorEncoding, IntegerVector> {
-
-    [StorableConstructor]
-    private SingleObjectiveIntegerVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveIntegerVectorProgrammableProblem(SingleObjectiveIntegerVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectiveIntegerVectorProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.IntegerVectorEncoding", "IntegerVectorEncoding", "IntegerVector")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveIntegerVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Real Vector Programmable Problem (single-objective)", "Represents a real vector single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveRealVectorProgrammableProblem : SingleObjectiveProgrammableProblem<RealVectorEncoding, RealVector> {
-
-    [StorableConstructor]
-    private SingleObjectiveRealVectorProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveRealVectorProgrammableProblem(SingleObjectiveRealVectorProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectiveRealVectorProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.RealVectorEncoding", "RealVectorEncoding", "RealVector")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveRealVectorProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Permutation Programmable Problem (single-objective)", "Represents a permutation single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectivePermutationProgrammableProblem : SingleObjectiveProgrammableProblem<PermutationEncoding, Permutation> {
-
-    [StorableConstructor]
-    private SingleObjectivePermutationProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectivePermutationProgrammableProblem(SingleObjectivePermutationProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectivePermutationProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.PermutationEncoding", "PermutationEncoding", "Permutation")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectivePermutationProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Symbolic Expression Tree Programmable Problem (single-objective)", "Represents a symbolic expression tree single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveSymbolicExpressionTreeProgrammableProblem : SingleObjectiveProgrammableProblem<SymbolicExpressionTreeEncoding, SymbolicExpressionTree> {
-
-    [StorableConstructor]
-    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveSymbolicExpressionTreeProgrammableProblem(SingleObjectiveSymbolicExpressionTreeProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectiveSymbolicExpressionTreeProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "SymbolicExpressionTreeEncoding", "SymbolicExpressionTree")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveSymbolicExpressionTreeProgrammableProblem(this, cloner);
-    }
-  }
-
-  [Item("Linear Linkage Programmable Problem (single-objective)", "Represents a linear linkage single-objective problem that can be programmed with a script.")]
-  [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
-  [StorableClass]
-  public sealed class SingleObjectiveLinearLinkageProgrammableProblem : SingleObjectiveProgrammableProblem<LinearLinkageEncoding, LinearLinkage> {
-
-    [StorableConstructor]
-    private SingleObjectiveLinearLinkageProgrammableProblem(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveLinearLinkageProgrammableProblem(SingleObjectiveLinearLinkageProgrammableProblem original, Cloner cloner) : base(original, cloner) { }
-    public SingleObjectiveLinearLinkageProgrammableProblem()
-      : base(string.Format(ScriptTemplates.CompiledSingleObjectiveProblemDefinition, "HeuristicLab.Encodings.LinearLinkageEncoding", "LinearLinkageEncoding", "LinearLinkage")) { }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveLinearLinkageProgrammableProblem(this, cloner);
-    }
-  }*/
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 13360)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.TestFunctions/3.3/SingleObjectiveTestFunctionProblem.cs	(revision 13361)
@@ -39,5 +39,7 @@
   [StorableClass]
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 90)]
-  public sealed class SingleObjectiveTestFunctionProblem : SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveTestFunctionProblemEvaluator, IRealVectorCreator>, IStorableContent, IProblemInstanceConsumer<SOTFData> {
+  public sealed class SingleObjectiveTestFunctionProblem :
+    SingleObjectiveHeuristicOptimizationProblem<ISingleObjectiveTestFunctionProblemEvaluator, IRealVectorCreator>,
+    ISingleObjectiveProblem<RealVectorEncoding, RealVector>, IStorableContent, IProblemInstanceConsumer<SOTFData> {
     public string Filename { get; set; }
 
