Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs	(revision 13336)
@@ -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("BinaryVector", "Represents a vector of binary values.")]
-  public class BinaryVector : BoolArray {
+  public class BinaryVector : BoolArray, ISolution {
     [StorableConstructor]
     protected BinaryVector(bool deserializing) : base(deserializing) { }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorEncoding.cs	(revision 13336)
@@ -34,5 +34,5 @@
   [Item("BinaryVectorEncoding", "Describes a binary vector encoding.")]
   [StorableClass]
-  public sealed class BinaryVectorEncoding : Encoding<IBinaryVectorCreator> {
+  public sealed class BinaryVectorEncoding : Encoding<BinaryVector> {
     #region Encoding Parameters
     [Storable]
@@ -166,14 +166,3 @@
     #endregion
   }
-
-  public static class IndividualExtensionMethods {
-    public static BinaryVector BinaryVector(this Individual individual) {
-      var encoding = individual.GetEncoding<BinaryVectorEncoding>();
-      return individual.BinaryVector(encoding.Name);
-    }
-
-    public static BinaryVector BinaryVector(this Individual individual, string name) {
-      return (BinaryVector)individual[name];
-    }
-  }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Interfaces/IBinaryVectorCreator.cs	(revision 13336)
@@ -28,5 +28,5 @@
   /// An interface which represents an operator for creating vectors of bool-valued data.
   /// </summary>
-  public interface IBinaryVectorCreator : IBinaryVectorOperator, ISolutionCreator {
+  public interface IBinaryVectorCreator : IBinaryVectorOperator, ISolutionCreator<BinaryVector> {
     IValueLookupParameter<IntValue> LengthParameter { get; }
     ILookupParameter<BinaryVector> BinaryVectorParameter { get; }
Index: /branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeProblem.cs	(revision 13336)
@@ -32,5 +32,5 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   [StorableClass]
-  public abstract class SymbolicExpressionTreeProblem : SingleObjectiveBasicProblem<SymbolicExpressionTreeEncoding> {
+  public abstract class SymbolicExpressionTreeProblem : SingleObjectiveProblem<SymbolicExpressionTreeEncoding> {
 
     // persistence
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization.Views/3.3/HeuristicLab.Optimization.Views-3.3.csproj	(revision 13336)
@@ -142,10 +142,4 @@
       <DependentUpon>BatchRunView.cs</DependentUpon>
     </Compile>
-    <Compile Include="CreateNewSingleEncodingDialog.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="CreateNewSingleEncodingDialog.Designer.cs">
-      <DependentUpon>CreateNewSingleEncodingDialog.cs</DependentUpon>
-    </Compile>
     <Compile Include="ISolutionSimilarityCalculatorView.cs">
       <SubType>UserControl</SubType>
@@ -159,10 +153,4 @@
     <Compile Include="ExperimentListView.Designer.cs">
       <DependentUpon>ExperimentListView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="MultiEncodingView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="MultiEncodingView.Designer.cs">
-      <DependentUpon>MultiEncodingView.cs</DependentUpon>
     </Compile>
     <Compile Include="Plugin.cs" />
@@ -427,9 +415,4 @@
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Include="CreateNewSingleEncodingDialog.resx">
-      <DependentUpon>CreateNewSingleEncodingDialog.cs</DependentUpon>
-    </EmbeddedResource>
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: anches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/BasicProblem.cs	(revision 13335)
+++ 	(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 System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Optimization {
-  [StorableClass]
-  public abstract class BasicProblem<TEncoding, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator>, IProblemDefinition, IStorableContent
-    where TEncoding : class, IEncoding
-    where TEvaluator : class, IEvaluator {
-
-    public string Filename { get; set; }
-
-    protected IValueParameter<TEncoding> EncodingParameter {
-      get { return (IValueParameter<TEncoding>)Parameters["Encoding"]; }
-    }
-
-    //mkommend necessary for reuse of operators if the encoding changes
-    private TEncoding oldEncoding;
-
-    IEncoding IProblemDefinition.Encoding { get { return Encoding; } }
-    public TEncoding Encoding {
-      get { return EncodingParameter.Value; }
-      protected set {
-        if (value == null) throw new ArgumentNullException("Encoding must not be null.");
-        EncodingParameter.Value = value;
-      }
-    }
-
-    protected override IEnumerable<IItem> GetOperators() {
-      if (Encoding == null) return base.GetOperators();
-      return base.GetOperators().Concat(Encoding.Operators);
-    }
-    public override IEnumerable<IParameterizedItem> ExecutionContextItems {
-      get {
-        if (Encoding == null) return base.ExecutionContextItems;
-        return base.ExecutionContextItems.Concat(new[] { Encoding });
-      }
-    }
-
-    protected BasicProblem()
-      : base() {
-      Parameters.Add(new ValueParameter<TEncoding>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
-      oldEncoding = Encoding;
-      if(Encoding != null) Parameterize();
-      RegisterEvents();
-    }
-
-    protected BasicProblem(BasicProblem<TEncoding, TEvaluator> original, Cloner cloner)
-      : base(original, cloner) {
-      oldEncoding = cloner.Clone(original.oldEncoding);
-      RegisterEvents();
-    }
-
-    [StorableConstructor]
-    protected BasicProblem(bool deserializing) : base(deserializing) { }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      oldEncoding = Encoding;
-      RegisterEvents();
-    }
-
-    private void RegisterEvents() {
-      EncodingParameter.ValueChanged += (o, e) => OnEncodingChanged();
-      var multiEncoding = Encoding as MultiEncoding;
-      if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
-    }
-
-    protected virtual void OnEncodingChanged() {
-      Parameterize();
-
-      OnOperatorsChanged();
-      OnReset();
-    }
-
-    private void Parameterize() {
-      if (oldEncoding != null) {
-        AdaptEncodingOperators(oldEncoding, Encoding);
-        var oldMultiEncoding = oldEncoding as MultiEncoding;
-        if (oldMultiEncoding != null)
-          oldMultiEncoding.EncodingsChanged -= MultiEncodingOnEncodingsChanged;
-      }
-      oldEncoding = Encoding;
-
-      foreach (var op in Operators.OfType<IEncodingOperator>())
-        op.EncodingParameter.ActualName = EncodingParameter.Name;
-
-      var solutionCreatorType = Encoding.GetType().BaseType.GetGenericArguments();
-      var paramType = typeof(ValueParameter<>).MakeGenericType(solutionCreatorType);
-      var solutionCreatorParam = (IParameter)Activator.CreateInstance(paramType, SolutionCreatorParameter.Name, SolutionCreatorParameter.Description,
-        Encoding.SolutionCreator);
-      Parameters.Remove(SolutionCreatorParameter);
-      Parameters.Add(solutionCreatorParam);
-      ((IValueParameter)solutionCreatorParam).ValueChanged += SolutionCreatorParameter_ValueChanged;
-
-      var multiEncoding = Encoding as MultiEncoding;
-      if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
-    }
-
-    protected override void OnSolutionCreatorChanged() {
-      base.OnSolutionCreatorChanged();
-      Encoding.SolutionCreator = SolutionCreator;
-    }
-
-    private static void AdaptEncodingOperators(IEncoding oldEncoding, IEncoding newEncoding) {
-      if (oldEncoding.GetType() != newEncoding.GetType()) return;
-
-      if (oldEncoding.GetType() == typeof(MultiEncoding)) {
-        var oldMultiEncoding = (MultiEncoding)oldEncoding;
-        var newMultiEncoding = (MultiEncoding)newEncoding;
-        if (!oldMultiEncoding.Encodings.SequenceEqual(newMultiEncoding.Encodings, new TypeEqualityComparer<IEncoding>())) return;
-
-        var nestedEncodings = oldMultiEncoding.Encodings.Zip(newMultiEncoding.Encodings, (o, n) => new { oldEnc = o, newEnc = n });
-        foreach (var multi in nestedEncodings)
-          AdaptEncodingOperators(multi.oldEnc, multi.newEnc);
-      }
-
-      var comparer = new TypeEqualityComparer<IOperator>();
-      var cloner = new Cloner();
-      var oldOperators = oldEncoding.Operators;
-      var newOperators = newEncoding.Operators;
-
-      cloner.RegisterClonedObject(oldEncoding, newEncoding);
-      var operators = oldOperators.Intersect(newOperators, comparer)
-                                  .Select(cloner.Clone)
-                                  .Union(newOperators, comparer).ToList();
-
-      newEncoding.ConfigureOperators(operators);
-      newEncoding.Operators = operators;
-    }
-
-    protected virtual void MultiEncodingOnEncodingsChanged(object sender, EventArgs e) {
-      OnOperatorsChanged();
-    }
-  }
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 13336)
@@ -31,6 +31,6 @@
   [Item("Encoding", "Base class for describing different encodings.")]
   [StorableClass]
-  public abstract class Encoding<T> : ParameterizedNamedItem, IEncoding
-    where T : class,ISolutionCreator {
+  public abstract class Encoding<TSolution> : ParameterizedNamedItem, IEncoding<TSolution>
+    where TSolution : class,ISolution {
     public override sealed bool CanChangeName {
       get { return false; }
@@ -48,11 +48,11 @@
       get { return encodingOperators; }
       set {
-        if (!value.OfType<T>().Any())
+        if (!value.OfType<ISolutionCreator<TSolution>>().Any())
           throw new ArgumentException("The provided operators contain no suitable solution creator");
         encodingOperators.Clear();
         foreach (var op in value) encodingOperators.Add(op);
 
-        T newSolutionCreator = (T)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType()) ??
-                               encodingOperators.OfType<T>().First();
+        ISolutionCreator<TSolution> newSolutionCreator = (ISolutionCreator<TSolution>)encodingOperators.FirstOrDefault(o => o.GetType() == solutionCreator.GetType()) ??
+                               encodingOperators.OfType<ISolutionCreator<TSolution>>().First();
         SolutionCreator = newSolutionCreator;
         OnOperatorsChanged();
@@ -60,14 +60,7 @@
     }
 
-    ISolutionCreator IEncoding.SolutionCreator {
-      get { return SolutionCreator; }
-      set {
-        if (!(value is T)) throw new ArgumentException(string.Format("Cannot assign the solution creator {0} to the encoding {1}.", value.GetType().GetPrettyName(), GetType().GetPrettyName()));
-        SolutionCreator = (T)value;
-      }
-    }
     [Storable]
-    private T solutionCreator;
-    public T SolutionCreator {
+    private ISolutionCreator<TSolution> solutionCreator;
+    public ISolutionCreator<TSolution> SolutionCreator {
       get {
         return solutionCreator;
@@ -85,5 +78,5 @@
     [StorableConstructor]
     protected Encoding(bool deserializing) : base(deserializing) { }
-    protected Encoding(Encoding<T> original, Cloner cloner)
+    protected Encoding(Encoding<TSolution> original, Cloner cloner)
       : base(original, cloner) {
       encodingOperators = cloner.Clone(original.encodingOperators);
@@ -93,8 +86,4 @@
       : base(name) {
       Parameters.Add(new FixedValueParameter<ReadOnlyItemSet<IOperator>>(name + ".Operators", "The operators that the encoding specifies.", encodingOperators.AsReadOnly()));
-    }
-
-    public virtual Individual GetIndividual(IScope scope) {
-      return new SingleEncodingIndividual(this, scope);
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 13336)
@@ -25,9 +25,9 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IEncoding : IParameterizedNamedItem {
-    ISolutionCreator SolutionCreator { get; set; }
+  public interface IEncoding<TSolution> : IParameterizedNamedItem
+    where TSolution : class, ISolution {
+    ISolutionCreator<TSolution> SolutionCreator { get; set; }
     IEnumerable<IOperator> Operators { get; set; }
 
-    Individual GetIndividual(IScope scope);
     void ConfigureOperator(IOperator @operator);
     void ConfigureOperators(IEnumerable<IOperator> operators);
@@ -36,3 +36,5 @@
     event EventHandler OperatorsChanged;
   }
+
+
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 13336)
@@ -23,6 +23,6 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IEncodingOperator : IOperator {
-    ILookupParameter<IEncoding> EncodingParameter { get; }
+  public interface IEncodingOperator<TSolution> : IOperator where TSolution : class, ISolution{
+    ILookupParameter<IEncoding<TSolution>> EncodingParameter { get; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiEncodingOperator.cs	(revision 13336)
@@ -23,7 +23,7 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IMultiEncodingOperator : IOperator {
-    void AddEncoding(IEncoding encoding);
-    bool RemoveEncoding(IEncoding encoding);
+  public interface IMultiEncodingOperator<TSolution> : IOperator where TSolution : class,ISolution {
+    void AddEncoding(IEncoding<TSolution> encoding);
+    bool RemoveEncoding(IEncoding<TSolution> encoding);
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 13336)
@@ -23,8 +23,9 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IMultiObjectiveProblemDefinition : IProblemDefinition {
+  public interface IMultiObjectiveProblemDefinition<TSolution> : IProblemDefinition
+  where TSolution : class, ISolution {
     bool[] Maximization { get; }
-    double[] Evaluate(Individual individual, IRandom random);
-    void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random);
+    double[] Evaluate(TSolution individual, IRandom random);
+    void Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 13336)
@@ -22,5 +22,5 @@
 namespace HeuristicLab.Optimization {
   public interface IProblemDefinition {
-    IEncoding Encoding { get; }
+    //IEncoding Encoding { get; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 13336)
@@ -24,9 +24,10 @@
 
 namespace HeuristicLab.Optimization {
-  public interface ISingleObjectiveProblemDefinition : IProblemDefinition {
+  public interface ISingleObjectiveProblemDefinition<TSolution> : IProblemDefinition
+  where TSolution : class, ISolution {
     bool Maximization { get; }
-    double Evaluate(Individual individual, IRandom random);
-    void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random);
-    IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random);
+    double Evaluate(TSolution individual, IRandom random);
+    void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
+    IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 13336)
@@ -24,6 +24,7 @@
 
 namespace HeuristicLab.Optimization {
-  internal interface IMultiObjectiveAnalysisOperator : IEncodingOperator, IAnalyzer, IMultiObjectiveOperator {
-    Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  internal interface IMultiObjectiveAnalysisOperator<TSolution> : IEncodingOperator<TSolution>, IAnalyzer, IMultiObjectiveOperator
+  where TSolution : class, ISolution {
+    Action<TSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 13336)
@@ -24,6 +24,7 @@
 
 namespace HeuristicLab.Optimization {
-  internal interface IMultiObjectiveEvaluationOperator : IMultiObjectiveEvaluator, IEncodingOperator {
-    Func<Individual, IRandom, double[]> EvaluateFunc { get; set; }
+  internal interface IMultiObjectiveEvaluationOperator<TSolution> : IMultiObjectiveEvaluator, IEncodingOperator<TSolution>
+  where TSolution : class, ISolution {
+    Func<TSolution, IRandom, double[]> EvaluateFunc { get; set; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 13336)
@@ -25,6 +25,7 @@
 
 namespace HeuristicLab.Optimization {
-  internal interface INeighborBasedOperator : IEncodingOperator {
-    Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+  internal interface INeighborBasedOperator<TSolution> : IEncodingOperator<TSolution>
+  where TSolution : class, ISolution {
+    Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 13336)
@@ -24,6 +24,7 @@
 
 namespace HeuristicLab.Optimization {
-  internal interface ISingleObjectiveAnalysisOperator : IEncodingOperator, ISingleObjectiveOperator {
-    Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  internal interface ISingleObjectiveAnalysisOperator<TSolution> : IEncodingOperator<TSolution>, ISingleObjectiveOperator
+  where TSolution : class, ISolution {
+    Action<TSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 13336)
@@ -24,6 +24,7 @@
 
 namespace HeuristicLab.Optimization {
-  internal interface ISingleObjectiveEvaluationOperator : ISingleObjectiveEvaluator, IEncodingOperator {
-    Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+  internal interface ISingleObjectiveEvaluationOperator<TSolution> : ISingleObjectiveEvaluator, IEncodingOperator<TSolution>
+  where TSolution : class, ISolution {
+    Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
   }
 }
Index: anches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 13335)
+++ 	(revision )
@@ -1,100 +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 System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Optimization {
-  [StorableClass]
-  public abstract class MultiObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, MultiObjectiveEvaluator>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition
-  where TEncoding : class, IEncoding {
-    [StorableConstructor]
-    protected MultiObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
-
-    protected MultiObjectiveBasicProblem(MultiObjectiveBasicProblem<TEncoding> original, Cloner cloner)
-      : base(original, cloner) {
-      ParameterizeOperators();
-    }
-
-    protected MultiObjectiveBasicProblem()
-      : base() {
-      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
-
-      Operators.Add(Evaluator);
-      Operators.Add(new MultiObjectiveAnalyzer());
-
-      ParameterizeOperators();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      ParameterizeOperators();
-    }
-
-    public abstract bool[] Maximization { get; }
-    public abstract double[] Evaluate(Individual individual, IRandom random);
-    public virtual void Analyze(Individual[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
-
-    protected override void OnOperatorsChanged() {
-      base.OnOperatorsChanged();
-      if (Encoding != null) {
-        PruneSingleObjectiveOperators(Encoding);
-        var multiEncoding = Encoding as MultiEncoding;
-        if (multiEncoding != null) {
-          foreach (var encoding in multiEncoding.Encodings.ToList()) {
-            PruneSingleObjectiveOperators(encoding);
-          }
-        }
-      }
-    }
-
-    private void PruneSingleObjectiveOperators(IEncoding encoding) {
-      if (encoding != null && encoding.Operators.Any(x => x is ISingleObjectiveOperator && !(x is IMultiObjectiveOperator)))
-        encoding.Operators = encoding.Operators.Where(x => !(x is ISingleObjectiveOperator) || x is IMultiObjectiveOperator).ToList();
-    }
-
-    protected override void OnEvaluatorChanged() {
-      base.OnEvaluatorChanged();
-      ParameterizeOperators();
-    }
-
-    private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<IMultiObjectiveEvaluationOperator>())
-        op.EvaluateFunc = Evaluate;
-      foreach (var op in Operators.OfType<IMultiObjectiveAnalysisOperator>())
-        op.AnalyzeAction = Analyze;
-    }
-
-
-    #region IMultiObjectiveHeuristicOptimizationProblem Members
-    IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
-      get { return Parameters["Maximization"]; }
-    }
-    IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
-      get { return Evaluator; }
-    }
-    #endregion
-  }
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 13336)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 13336)
@@ -0,0 +1,101 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class MultiObjectiveProblem<TSolution> : Problem<TSolution, MultiObjectiveEvaluator<TSolution>>, IMultiObjectiveHeuristicOptimizationProblem, IMultiObjectiveProblemDefinition<TSolution>
+  where TSolution : class, ISolution {
+    [StorableConstructor]
+    protected MultiObjectiveProblem(bool deserializing) : base(deserializing) { }
+
+    protected MultiObjectiveProblem(MultiObjectiveProblem<TSolution> original, Cloner cloner)
+      : base(original, cloner) {
+      ParameterizeOperators();
+    }
+
+    protected MultiObjectiveProblem()
+      : base() {
+      Parameters.Add(new ValueParameter<BoolArray>("Maximization", "Set to false if the problem should be minimized.", (BoolArray)new BoolArray(Maximization).AsReadOnly()));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new MultiObjectiveAnalyzer<TSolution>());
+
+      ParameterizeOperators();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      ParameterizeOperators();
+    }
+
+    public abstract bool[] Maximization { get; }
+    public abstract double[] Evaluate(TSolution individual, IRandom random);
+    public virtual void Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
+
+    //TODO
+    //protected override void OnOperatorsChanged() {
+    //  base.OnOperatorsChanged();
+    //  if (Encoding != null) {
+    //    PruneSingleObjectiveOperators(Encoding);
+    //    var multiEncoding = Encoding as MultiEncoding;
+    //    if (multiEncoding != null) {
+    //      foreach (var encoding in multiEncoding.Encodings.ToList()) {
+    //        PruneSingleObjectiveOperators(encoding);
+    //      }
+    //    }
+    //  }
+    //}
+
+    //private void PruneSingleObjectiveOperators(IEncoding encoding) {
+    //  if (encoding != null && encoding.Operators.Any(x => x is ISingleObjectiveOperator && !(x is IMultiObjectiveOperator)))
+    //    encoding.Operators = encoding.Operators.Where(x => !(x is ISingleObjectiveOperator) || x is IMultiObjectiveOperator).ToList();
+    //}
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<IMultiObjectiveEvaluationOperator<TSolution>>())
+        op.EvaluateFunc = Evaluate;
+      foreach (var op in Operators.OfType<IMultiObjectiveAnalysisOperator<TSolution>>())
+        op.AnalyzeAction = Analyze;
+    }
+
+
+    #region IMultiObjectiveHeuristicOptimizationProblem Members
+    IParameter IMultiObjectiveHeuristicOptimizationProblem.MaximizationParameter {
+      get { return Parameters["Maximization"]; }
+    }
+    IMultiObjectiveEvaluator IMultiObjectiveHeuristicOptimizationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    #endregion
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 13336)
@@ -33,9 +33,10 @@
   [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
   [StorableClass]
-  public class MultiObjectiveAnalyzer : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator, IStochasticOperator {
+  public class MultiObjectiveAnalyzer<TSolution> : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator<TSolution>, IStochasticOperator
+  where TSolution : class, ISolution {
     public bool EnabledByDefault { get { return true; } }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -52,12 +53,12 @@
     }
 
-    public Action<Individual[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+    public Action<TSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
     protected MultiObjectiveAnalyzer(bool deserializing) : base(deserializing) { }
-    protected MultiObjectiveAnalyzer(MultiObjectiveAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveAnalyzer(MultiObjectiveAnalyzer<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public MultiObjectiveAnalyzer() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("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."));
@@ -65,5 +66,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveAnalyzer(this, cloner);
+      return new MultiObjectiveAnalyzer<TSolution>(this, cloner);
     }
 
@@ -77,5 +78,5 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var individuals = scopes.Select(encoding.GetIndividual).ToArray();
+      var individuals = scopes.Select(s => ScopeUtil.GetSolution(s, encoding)).ToArray();
       AnalyzeAction(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results, random);
       return base.Apply();
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 13336)
@@ -31,5 +31,6 @@
   [Item("Multi-objective Evaluator", "Calls the Evaluate method of the problem definition and writes the return value into the scope.")]
   [StorableClass]
-  public class MultiObjectiveEvaluator : InstrumentedOperator, IMultiObjectiveEvaluationOperator, IStochasticOperator {
+  public class MultiObjectiveEvaluator<TSolution> : InstrumentedOperator, IMultiObjectiveEvaluationOperator<TSolution>, IStochasticOperator
+  where TSolution : class, ISolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -37,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -45,17 +46,17 @@
     }
 
-    public Func<Individual, IRandom, double[]> EvaluateFunc { get; set; }
+    public Func<TSolution, IRandom, double[]> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     protected MultiObjectiveEvaluator(bool deserializing) : base(deserializing) { }
-    protected MultiObjectiveEvaluator(MultiObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveEvaluator(MultiObjectiveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public MultiObjectiveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleArray>("Qualities", "The qualities of the parameter vector."));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveEvaluator(this, cloner);
+      return new MultiObjectiveEvaluator<TSolution>(this, cloner);
     }
 
@@ -63,6 +64,6 @@
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
-      QualitiesParameter.ActualValue = new DoubleArray(EvaluateFunc(individual, random));
+      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      QualitiesParameter.ActualValue = new DoubleArray(EvaluateFunc(solution, random));
       return base.InstrumentedApply();
     }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 13336)
@@ -33,9 +33,10 @@
   [Item("Single-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
   [StorableClass]
-  public sealed class SingleObjectiveAnalyzer : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator, IAnalyzer, IStochasticOperator {
+  public sealed class SingleObjectiveAnalyzer<TSolution> : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator<TSolution>, IAnalyzer, IStochasticOperator
+  where TSolution : class, ISolution {
     public bool EnabledByDefault { get { return true; } }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -52,11 +53,11 @@
     }
 
-    public Action<Individual[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+    public Action<TSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveAnalyzer(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveAnalyzer(SingleObjectiveAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveAnalyzer(SingleObjectiveAnalyzer<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveAnalyzer() {
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("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."));
@@ -65,5 +66,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveAnalyzer(this, cloner);
+      return new SingleObjectiveAnalyzer<TSolution>(this, cloner);
     }
 
@@ -77,5 +78,5 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var individuals = scopes.Select(encoding.GetIndividual).ToArray();
+      var individuals = scopes.Select(s => ScopeUtil.GetSolution(s, encoding)).ToArray();
       AnalyzeAction(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results, random);
       return base.Apply();
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 13336)
@@ -31,5 +31,6 @@
   [Item("Single-objective Evaluator", "Calls the script's Evaluate method to get the quality value of the parameter vector.")]
   [StorableClass]
-  public sealed class SingleObjectiveEvaluator : InstrumentedOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
+  public sealed class SingleObjectiveEvaluator<TSolution> : InstrumentedOperator, ISingleObjectiveEvaluationOperator<TSolution>, IStochasticOperator
+  where TSolution : class, ISolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -37,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -45,22 +46,22 @@
     }
 
-    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveEvaluator(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveEvaluator(SingleObjectiveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveEvaluator(SingleObjectiveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("Encoding", "An item that holds the problem's encoding."));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveEvaluator(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveEvaluator<TSolution>(this, cloner); }
 
     public override IOperation InstrumentedApply() {
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
-      QualityParameter.ActualValue = new DoubleValue(EvaluateFunc(individual, random));
+      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      QualityParameter.ActualValue = new DoubleValue(EvaluateFunc(solution, random));
       return base.InstrumentedApply();
     }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 13336)
@@ -33,11 +33,12 @@
   [Item("Single-objective Improver", "Improves a solution by calling GetNeighbors and Evaluate of the corresponding problem definition.")]
   [StorableClass]
-  public sealed class SingleObjectiveImprover : SingleSuccessorOperator, INeighborBasedOperator, IImprovementOperator, ISingleObjectiveEvaluationOperator, IStochasticOperator {
+  public sealed class SingleObjectiveImprover<TSolution> : SingleSuccessorOperator, INeighborBasedOperator<TSolution>, IImprovementOperator, ISingleObjectiveEvaluationOperator<TSolution>, IStochasticOperator
+    where TSolution : class, ISolution {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -62,13 +63,13 @@
     }
 
-    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
-    public Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveImprover(bool deserializing) : base(deserializing) { }
-    private SingleObjectiveImprover(SingleObjectiveImprover original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveImprover(SingleObjectiveImprover<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveImprover() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("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."));
@@ -79,5 +80,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveImprover(this, cloner);
+      return new SingleObjectiveImprover<TSolution>(this, cloner);
     }
 
@@ -88,12 +89,12 @@
       var maxAttempts = ImprovementAttemptsParameter.ActualValue.Value;
       var sampleSize = SampleSizeParameter.ActualValue.Value;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
-      var quality = QualityParameter.ActualValue == null ? EvaluateFunc(individual, random) : QualityParameter.ActualValue.Value;
+      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var quality = QualityParameter.ActualValue == null ? EvaluateFunc(solution, random) : QualityParameter.ActualValue.Value;
 
       var count = 0;
       for (var i = 0; i < maxAttempts; i++) {
-        Individual best = null;
+        TSolution best = default(TSolution);
         var bestQuality = quality;
-        foreach (var neighbor in GetNeighborsFunc(individual, random).Take(sampleSize)) {
+        foreach (var neighbor in GetNeighborsFunc(solution, random).Take(sampleSize)) {
           var q = EvaluateFunc(neighbor, random);
           count++;
@@ -103,5 +104,5 @@
         }
         if (best == null) break;
-        individual = best;
+        solution = best;
         quality = bestQuality;
       }
@@ -109,5 +110,6 @@
       LocalEvaluatedSolutionsParameter.ActualValue = new IntValue(count);
       QualityParameter.ActualValue = new DoubleValue(quality);
-      individual.CopyToScope(ExecutionContext.Scope);
+
+      ScopeUtil.CopySolutionToScope(ExecutionContext.Scope, encoding, solution);
       return base.Apply();
     }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 13336)
@@ -31,5 +31,6 @@
   [Item("Single-objective MoveEvaluator", "Evaluates a parameter vector that results from a move.")]
   [StorableClass]
-  public class SingleObjectiveMoveEvaluator : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator, ISingleObjectiveMoveEvaluator, IStochasticOperator, ISingleObjectiveMoveOperator {
+  public class SingleObjectiveMoveEvaluator<TSolution> : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator<TSolution>, ISingleObjectiveMoveEvaluator, IStochasticOperator, ISingleObjectiveMoveOperator
+  where TSolution : class, ISolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -37,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -49,12 +50,12 @@
     }
 
-    public Func<Individual, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     protected SingleObjectiveMoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected SingleObjectiveMoveEvaluator(SingleObjectiveMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveMoveEvaluator(SingleObjectiveMoveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveMoveEvaluator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("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."));
@@ -62,5 +63,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveEvaluator(this, cloner);
+      return new SingleObjectiveMoveEvaluator<TSolution>(this, cloner);
     }
 
@@ -68,5 +69,5 @@
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
+      var individual = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
       MoveQualityParameter.ActualValue = new DoubleValue(EvaluateFunc(individual, random));
       return base.Apply();
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 13336)
@@ -34,5 +34,6 @@
   [Item("Single-objective MoveGenerator", "Calls the GetNeighbors method of the problem definition to obtain the moves.")]
   [StorableClass]
-  public class SingleObjectiveMoveGenerator : SingleSuccessorOperator, INeighborBasedOperator, IMultiMoveGenerator, IStochasticOperator, ISingleObjectiveMoveOperator {
+  public class SingleObjectiveMoveGenerator<TSolution> : SingleSuccessorOperator, INeighborBasedOperator<TSolution>, IMultiMoveGenerator, IStochasticOperator, ISingleObjectiveMoveOperator
+  where TSolution : class, ISolution {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
@@ -43,22 +44,22 @@
     }
 
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
-    public Func<Individual, IRandom, IEnumerable<Individual>> GetNeighborsFunc { get; set; }
+    public Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
 
     [StorableConstructor]
     protected SingleObjectiveMoveGenerator(bool deserializing) : base(deserializing) { }
-    protected SingleObjectiveMoveGenerator(SingleObjectiveMoveGenerator original, Cloner cloner)
+    protected SingleObjectiveMoveGenerator(SingleObjectiveMoveGenerator<TSolution> original, Cloner cloner)
       : base(original, cloner) { }
     public SingleObjectiveMoveGenerator() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
       Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to sample."));
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("Encoding", "An item that holds the problem's encoding."));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveGenerator(this, cloner);
+      return new SingleObjectiveMoveGenerator<TSolution>(this, cloner);
     }
 
@@ -67,11 +68,11 @@
       var sampleSize = SampleSizeParameter.ActualValue.Value;
       var encoding = EncodingParameter.ActualValue;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
-      var nbhood = GetNeighborsFunc(individual, random).Take(sampleSize).ToList();
+      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var nbhood = GetNeighborsFunc(solution, random).Take(sampleSize).ToList();
 
       var moveScopes = new Scope[nbhood.Count];
       for (int i = 0; i < moveScopes.Length; i++) {
         moveScopes[i] = new Scope(i.ToString(CultureInfo.InvariantCulture.NumberFormat));
-        nbhood[i].CopyToScope(moveScopes[i]);
+        ScopeUtil.CopySolutionToScope(moveScopes[i], encoding, nbhood[i]);
       }
       ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 13336)
@@ -31,7 +31,8 @@
   [Item("Single-objective MoveMaker", "Applies a move.")]
   [StorableClass]
-  public class SingleObjectiveMoveMaker : InstrumentedOperator, IMoveMaker, ISingleObjectiveMoveOperator {
-    public ILookupParameter<IEncoding> EncodingParameter {
-      get { return (ILookupParameter<IEncoding>)Parameters["Encoding"]; }
+  public class SingleObjectiveMoveMaker<TSolution> : InstrumentedOperator, IMoveMaker, ISingleObjectiveMoveOperator
+  where TSolution : class, ISolution {
+    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
     }
 
@@ -46,7 +47,7 @@
     [StorableConstructor]
     protected SingleObjectiveMoveMaker(bool deserializing) : base(deserializing) { }
-    protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker<TSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveMoveMaker() {
-      Parameters.Add(new LookupParameter<IEncoding>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("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."));
@@ -54,5 +55,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveMaker(this, cloner);
+      return new SingleObjectiveMoveMaker<TSolution>(this, cloner);
     }
 
@@ -61,6 +62,6 @@
 
       var encoding = EncodingParameter.ActualValue;
-      var individual = encoding.GetIndividual(ExecutionContext.Scope);
-      individual.CopyToScope(ExecutionContext.Scope.Parent.Parent);
+      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      ScopeUtil.CopySolutionToScope(ExecutionContext.Scope.Parent.Parent, encoding, solution);
 
       if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 13336)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 13336)
@@ -0,0 +1,110 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class Problem<TSolution, TEvaluator> : HeuristicOptimizationProblem<TEvaluator, ISolutionCreator<TSolution>>, IProblemDefinition, IStorableContent
+    where TSolution : class, ISolution
+    where TEvaluator : class, IEvaluator {
+
+    public string Filename { get; set; }
+
+    protected IValueParameter<IEncoding<TSolution>> EncodingParameter {
+      get { return (IValueParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    }
+
+    public IEncoding<TSolution> Encoding {
+      get { return EncodingParameter.Value; }
+      protected set {
+        if (value == null) throw new ArgumentNullException("Encoding must not be null.");
+        EncodingParameter.Value = value;
+      }
+    }
+
+    protected override IEnumerable<IItem> GetOperators() {
+      if (Encoding == null) return base.GetOperators();
+      return base.GetOperators().Concat(Encoding.Operators);
+    }
+    public override IEnumerable<IParameterizedItem> ExecutionContextItems {
+      get {
+        if (Encoding == null) return base.ExecutionContextItems;
+        return base.ExecutionContextItems.Concat(new[] { Encoding });
+      }
+    }
+
+    protected Problem()
+      : base() {
+      Parameters.Add(new ValueParameter<IEncoding<TSolution>>("Encoding", "Describes the configuration of the encoding, what the variables are called, what type they are and their bounds if any."));
+      if (Encoding != null) Parameterize();
+      RegisterEvents();
+    }
+
+    protected Problem(Problem<TSolution, TEvaluator> original, Cloner cloner)
+      : base(original, cloner) {
+      RegisterEvents();
+    }
+
+    [StorableConstructor]
+    protected Problem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterEvents();
+    }
+
+    private void RegisterEvents() {
+      EncodingParameter.ValueChanged += (o, e) => OnEncodingChanged();
+      //var multiEncoding = Encoding as MultiEncoding;
+      //if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
+    }
+
+    protected virtual void OnEncodingChanged() {
+      Parameterize();
+
+      OnOperatorsChanged();
+      OnReset();
+    }
+
+    private void Parameterize() {
+      foreach (var op in Operators.OfType<IEncodingOperator<TSolution>>())
+        op.EncodingParameter.ActualName = EncodingParameter.Name;
+
+      //var multiEncoding = Encoding as MultiEncoding;
+      //if (multiEncoding != null) multiEncoding.EncodingsChanged += MultiEncodingOnEncodingsChanged;
+    }
+
+    protected override void OnSolutionCreatorChanged() {
+      base.OnSolutionCreatorChanged();
+      Encoding.SolutionCreator = SolutionCreator;
+    }
+
+    protected virtual void MultiEncodingOnEncodingsChanged(object sender, EventArgs e) {
+      OnOperatorsChanged();
+    }
+  }
+}
Index: anches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveBasicProblem.cs	(revision 13335)
+++ 	(revision )
@@ -1,130 +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 System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Optimization {
-  [StorableClass]
-  public abstract class SingleObjectiveBasicProblem<TEncoding> : BasicProblem<TEncoding, SingleObjectiveEvaluator>,
-    ISingleObjectiveProblemDefinition, ISingleObjectiveHeuristicOptimizationProblem
-  where TEncoding : class, IEncoding {
-
-    protected IValueParameter<DoubleValue> BestKnownQualityParameter {
-      get { return (IValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
-    }
-
-    public double BestKnownQuality {
-      get {
-        if (BestKnownQualityParameter.Value == null) return double.NaN;
-        return BestKnownQualityParameter.Value.Value;
-      }
-      set {
-        if (BestKnownQualityParameter.Value == null) BestKnownQualityParameter.Value = new DoubleValue(value);
-        else BestKnownQualityParameter.Value.Value = value;
-      }
-    }
-
-    [StorableConstructor]
-    protected SingleObjectiveBasicProblem(bool deserializing) : base(deserializing) { }
-
-    protected SingleObjectiveBasicProblem(SingleObjectiveBasicProblem<TEncoding> original, Cloner cloner)
-      : base(original, cloner) {
-      ParameterizeOperators();
-    }
-
-    protected SingleObjectiveBasicProblem()
-      : base() {
-      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
-      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
-
-      Operators.Add(Evaluator);
-      Operators.Add(new SingleObjectiveAnalyzer());
-      Operators.Add(new SingleObjectiveImprover());
-      Operators.Add(new SingleObjectiveMoveEvaluator());
-      Operators.Add(new SingleObjectiveMoveGenerator());
-      Operators.Add(new SingleObjectiveMoveMaker());
-
-      ParameterizeOperators();
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      ParameterizeOperators();
-    }
-
-    public abstract bool Maximization { get; }
-    public abstract double Evaluate(Individual individual, IRandom random);
-    public virtual void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) { }
-    public virtual IEnumerable<Individual> GetNeighbors(Individual individual, IRandom random) {
-      return Enumerable.Empty<Individual>();
-    }
-
-    protected override void OnOperatorsChanged() {
-      base.OnOperatorsChanged();
-      if (Encoding != null) {
-        PruneMultiObjectiveOperators(Encoding);
-        var multiEncoding = Encoding as MultiEncoding;
-        if (multiEncoding != null) {
-          foreach (var encoding in multiEncoding.Encodings.ToList()) {
-            PruneMultiObjectiveOperators(encoding);
-          }
-        }
-      }
-    }
-
-    private void PruneMultiObjectiveOperators(IEncoding encoding) {
-      if (encoding.Operators.Any(x => x is IMultiObjectiveOperator && !(x is ISingleObjectiveOperator)))
-        encoding.Operators = encoding.Operators.Where(x => !(x is IMultiObjectiveOperator) || x is ISingleObjectiveOperator).ToList();
-    }
-
-    protected override void OnEvaluatorChanged() {
-      base.OnEvaluatorChanged();
-      ParameterizeOperators();
-    }
-
-    private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator>())
-        op.EvaluateFunc = Evaluate;
-      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator>())
-        op.AnalyzeAction = Analyze;
-      foreach (var op in Operators.OfType<INeighborBasedOperator>())
-        op.GetNeighborsFunc = GetNeighbors;
-    }
-
-    #region ISingleObjectiveHeuristicOptimizationProblem Members
-    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
-      get { return Parameters["Maximization"]; }
-    }
-    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
-      get { return Parameters["BestKnownQuality"]; }
-    }
-    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
-      get { return Evaluator; }
-    }
-    #endregion
-  }
-}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13336)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 13336)
@@ -0,0 +1,135 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Optimization {
+  [StorableClass]
+  public abstract class SingleObjectiveProblem<TSolution> : Problem<TSolution, SingleObjectiveEvaluator<TSolution>>,
+    ISingleObjectiveProblemDefinition<TSolution>, ISingleObjectiveHeuristicOptimizationProblem
+  where TSolution : class, ISolution {
+
+    protected IValueParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+
+    public double BestKnownQuality {
+      get {
+        if (BestKnownQualityParameter.Value == null) return double.NaN;
+        return BestKnownQualityParameter.Value.Value;
+      }
+      set {
+        if (BestKnownQualityParameter.Value == null) BestKnownQualityParameter.Value = new DoubleValue(value);
+        else BestKnownQualityParameter.Value.Value = value;
+      }
+    }
+
+    [StorableConstructor]
+    protected SingleObjectiveProblem(bool deserializing) : base(deserializing) { }
+
+    protected SingleObjectiveProblem(SingleObjectiveProblem<TSolution> original, Cloner cloner)
+      : base(original, cloner) {
+      ParameterizeOperators();
+    }
+
+    protected SingleObjectiveProblem()
+      : base() {
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
+      Parameters.Add(new OptionalValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this problem."));
+
+      Operators.Add(Evaluator);
+      Operators.Add(new SingleObjectiveAnalyzer<TSolution>());
+      Operators.Add(new SingleObjectiveImprover<TSolution>());
+      Operators.Add(new SingleObjectiveMoveEvaluator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveGenerator<TSolution>());
+      Operators.Add(new SingleObjectiveMoveMaker<TSolution>());
+
+      ParameterizeOperators();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      ParameterizeOperators();
+    }
+
+    public abstract bool Maximization { get; }
+    public abstract double Evaluate(TSolution individual, IRandom random);
+    public virtual void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) { }
+    public virtual IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random) {
+      return Enumerable.Empty<TSolution>();
+    }
+
+    public virtual bool IsBetter(double quality, double bestQuality) {
+      return (Maximization && quality > bestQuality || !Maximization && quality < bestQuality);
+    }
+
+    //TODO
+    //protected override void OnOperatorsChanged() {
+    //  base.OnOperatorsChanged();
+    //  if (Encoding != null) {
+    //    PruneMultiObjectiveOperators(Encoding);
+    //    var multiEncoding = Encoding as MultiEncoding;
+    //    if (multiEncoding != null) {
+    //      foreach (var encoding in multiEncoding.Encodings.ToList()) {
+    //        PruneMultiObjectiveOperators(encoding);
+    //      }
+    //    }
+    //  }
+    //}
+
+    //private void PruneMultiObjectiveOperators(IEncoding<TSolution> encoding) {
+    //  if (encoding.Operators.Any(x => x is IMultiObjectiveOperator && !(x is ISingleObjectiveOperator)))
+    //    encoding.Operators = encoding.Operators.Where(x => !(x is IMultiObjectiveOperator) || x is ISingleObjectiveOperator).ToList();
+    //}
+
+    protected override void OnEvaluatorChanged() {
+      base.OnEvaluatorChanged();
+      ParameterizeOperators();
+    }
+
+    private void ParameterizeOperators() {
+      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator<TSolution>>())
+        op.EvaluateFunc = Evaluate;
+      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator<TSolution>>())
+        op.AnalyzeAction = Analyze;
+      foreach (var op in Operators.OfType<INeighborBasedOperator<TSolution>>())
+        op.GetNeighborsFunc = GetNeighbors;
+    }
+
+    #region ISingleObjectiveHeuristicOptimizationProblem Members
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
+      get { return Parameters["Maximization"]; }
+    }
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
+      get { return Parameters["BestKnownQuality"]; }
+    }
+    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    #endregion
+  }
+}
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 13336)
@@ -121,9 +121,7 @@
   <ItemGroup>
     <Compile Include="Algorithms\BasicAlgorithm.cs" />
-    <Compile Include="BasicProblems\BasicProblem.cs" />
+    <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblem.cs" />
+    <Compile Include="BasicProblems\Problem.cs" />
     <Compile Include="BasicProblems\Encoding.cs" />
-    <Compile Include="BasicProblems\Individuals\Individual.cs" />
-    <Compile Include="BasicProblems\Individuals\MultiEncodingIndividual.cs" />
-    <Compile Include="BasicProblems\Individuals\SingleEncodingIndividual.cs" />
     <Compile Include="BasicProblems\Interfaces\IEncoding.cs" />
     <Compile Include="BasicProblems\Interfaces\IEncodingOperator.cs" />
@@ -138,12 +136,9 @@
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveMoveOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblemDefinition.cs" />
-    <Compile Include="BasicProblems\MultiEncoding.cs" />
-    <Compile Include="BasicProblems\MultiObjectiveBasicProblem.cs" />
-    <Compile Include="BasicProblems\Operators\MultiEncodingCreator.cs" />
-    <Compile Include="BasicProblems\Operators\MultiEncodingCrossover.cs" />
-    <Compile Include="BasicProblems\Operators\MultiEncodingManipulator.cs" />
-    <Compile Include="BasicProblems\Operators\MultiEncodingOperator.cs" />
+    <Compile Include="BasicProblems\Interfaces\ISolution.cs" />
+    <Compile Include="BasicProblems\MultiObjectiveProblem.cs" />
     <Compile Include="BasicProblems\Operators\MultiObjectiveAnalyzer.cs" />
     <Compile Include="BasicProblems\Operators\MultiObjectiveEvaluator.cs" />
+    <Compile Include="BasicProblems\Operators\ScopeUtil.cs" />
     <Compile Include="BasicProblems\Operators\SingleObjectiveAnalyzer.cs" />
     <Compile Include="BasicProblems\Operators\SingleObjectiveEvaluator.cs" />
@@ -152,5 +147,5 @@
     <Compile Include="BasicProblems\Operators\SingleObjectiveMoveGenerator.cs" />
     <Compile Include="BasicProblems\Operators\SingleObjectiveMoveMaker.cs" />
-    <Compile Include="BasicProblems\SingleObjectiveBasicProblem.cs" />
+    <Compile Include="BasicProblems\SingleObjectiveProblem.cs" />
     <Compile Include="Interfaces\ILocalImprovementAlgorithmOperator.cs" />
     <Compile Include="Interfaces\IMultiObjectiveOperator.cs" />
@@ -328,5 +323,7 @@
     </BootstrapperPackage>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="BasicProblems\Individuals\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 13336)
@@ -31,8 +31,11 @@
     IEnumerable<IItem> Operators { get; }
 
-
     IEnumerable<IParameterizedItem> ExecutionContextItems { get; }
     event EventHandler OperatorsChanged;
     event EventHandler Reset;
   }
+
+  public interface IProblem<TSolution> : IHeuristicOptimizationProblem where TSolution : class, ISolution {
+    IEncoding<TSolution> Encoding { get; }
+  }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 13336)
@@ -27,3 +27,5 @@
   /// </summary>
   public interface ISolutionCreator : IOperator { }
+
+  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution { }
 }
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/BinaryProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/BinaryProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Binary/3.3/BinaryProblem.cs	(revision 13336)
@@ -34,8 +34,13 @@
 namespace HeuristicLab.Problems.Binary {
   [StorableClass]
-  public abstract class BinaryProblem : SingleObjectiveBasicProblem<BinaryVectorEncoding> {
+  public abstract class BinaryProblem : SingleObjectiveProblem<BinaryVector> {
     public virtual int Length {
       get { return Encoding.Length; }
       set { Encoding.Length = value; }
+    }
+
+    public new BinaryVectorEncoding Encoding {
+      get { return (BinaryVectorEncoding)base.Encoding; }
+      set { base.Encoding = value; }
     }
 
@@ -60,18 +65,10 @@
       var lengthParameter = new FixedValueParameter<IntValue>("Length", "The length of the BinaryVector.", new IntValue(10));
       Parameters.Add(lengthParameter);
+      Encoding = new BinaryVectorEncoding();
       Encoding.LengthParameter = lengthParameter;
       RegisterEventHandlers();
     }
 
-    public virtual bool IsBetter(double quality, double bestQuality) {
-      return (Maximization && quality > bestQuality || !Maximization && quality < bestQuality);
-    }
-
-    public abstract double Evaluate(BinaryVector vector, IRandom random);
-    public sealed override double Evaluate(Individual individual, IRandom random) {
-      return Evaluate(individual.BinaryVector(), random);
-    }
-
-    public override void Analyze(Individual[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    public override void Analyze(BinaryVector[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       base.Analyze(individuals, qualities, results, random);
       var orderedIndividuals = individuals.Zip(qualities, (i, q) => new { Individual = i, Quality = q }).OrderBy(z => z.Quality);
@@ -81,5 +78,5 @@
         results.Add(new Result("Best Solution", typeof(BinaryVector)));
       }
-      results["Best Solution"].Value = (IItem)best.BinaryVector().Clone();
+      results["Best Solution"].Value = (IItem)best.Clone();
     }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs	(revision 13336)
@@ -40,5 +40,5 @@
   // BackwardsCompatibility3.3
   // Rename class to SingleObjectiveExternalEvaluationProblem
-  public class ExternalEvaluationProblem : SingleObjectiveBasicProblem<IEncoding>, IExternalEvaluationProblem {
+  public class ExternalEvaluationProblem : SingleObjectiveProblem<IEncoding>, IExternalEvaluationProblem {
 
     public static new Image StaticItemImage {
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs	(revision 13336)
@@ -37,5 +37,5 @@
   [Creatable(CreatableAttribute.Categories.ExternalEvaluationProblems, Priority = 200)]
   [StorableClass]
-  public class MultiObjectiveExternalEvaluationProblem : MultiObjectiveBasicProblem<IEncoding>, IExternalEvaluationProblem {
+  public class MultiObjectiveExternalEvaluationProblem : MultiObjectiveProblem<IEncoding>, IExternalEvaluationProblem {
 
     public static new Image StaticItemImage {
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.GrammaticalEvolution/3.4/ArtificialAnt/GEArtificialAntProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.GrammaticalEvolution/3.4/ArtificialAnt/GEArtificialAntProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.GrammaticalEvolution/3.4/ArtificialAnt/GEArtificialAntProblem.cs	(revision 13336)
@@ -38,5 +38,5 @@
   [Creatable(CreatableAttribute.Categories.GeneticProgrammingProblems, Priority = 170)]
   [StorableClass]
-  public sealed class GEArtificialAntProblem : SingleObjectiveBasicProblem<IntegerVectorEncoding>, IStorableContent {
+  public sealed class GEArtificialAntProblem : SingleObjectiveProblem<IntegerVectorEncoding>, IStorableContent {
     public string Filename { get; set; }
 
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 13336)
@@ -33,5 +33,5 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 120)]
   [StorableClass]
-  public sealed class MultiObjectiveProgrammableProblem : MultiObjectiveBasicProblem<IEncoding>, IProgrammableItem {
+  public sealed class MultiObjectiveProgrammableProblem : MultiObjectiveProblem<IEncoding>, IProgrammableItem {
     public static new Image StaticItemImage {
       get { return VSImageLibrary.Script; }
Index: /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 13335)
+++ /branches/ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 13336)
@@ -35,5 +35,5 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 100)]
   [StorableClass]
-  public sealed class SingleObjectiveProgrammableProblem : SingleObjectiveBasicProblem<IEncoding>, IProgrammableItem {
+  public sealed class SingleObjectiveProgrammableProblem : SingleObjectiveProblem<IEncoding>, IProgrammableItem {
     public static new Image StaticItemImage {
       get { return VSImageLibrary.Script; }
