Index: /branches/2521_ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Analysis/3.3/AlleleFrequencyAnalysis/AlleleFrequencyAnalyzer.cs	(revision 16751)
@@ -37,5 +37,5 @@
   [Item("AlleleFrequencyAnalyzer", "An operator for analyzing the frequency of alleles.")]
   [StorableType("FB4ABEB4-E94E-4B79-9356-8AC48D8F77BE")]
-  public abstract class AlleleFrequencyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator where T : class, ISolution {
+  public abstract class AlleleFrequencyAnalyzer<T> : SingleSuccessorOperator, IAnalyzer, ISingleObjectiveOperator where T : class, IEncodedSolution {
     public virtual bool EnabledByDefault {
       get { return false; }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVector.cs	(revision 16751)
@@ -29,5 +29,5 @@
   [StorableType("B349929A-675C-41F4-AEB9-EEA3121E73A9")]
   [Item("BinaryVector", "Represents a vector of binary values.")]
-  public class BinaryVector : BoolArray, ISolution {
+  public class BinaryVector : BoolArray, IEncodedSolution {
     [StorableConstructor]
     protected BinaryVector(StorableConstructorFlag _) : base(_) { }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 16751)
@@ -30,5 +30,5 @@
   [StorableType("2DDD33C1-4732-478B-83B1-17226A8F2B61")]
   [Item("IntegerVector", "Represents a vector of integer values.")]
-  public class IntegerVector : IntArray, ISolution {
+  public class IntegerVector : IntArray, IEncodedSolution {
     [StorableConstructor]
     protected IntegerVector(StorableConstructorFlag _) : base(_) { }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkage.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkage.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.LinearLinkageEncoding/3.4/LinearLinkage.cs	(revision 16751)
@@ -32,5 +32,5 @@
   [Item("LinearLinkage", "Represents an LLE grouping of items.")]
   [StorableType("91492281-3335-4F5A-82BA-BA76142DAD2D")]
-  public sealed class LinearLinkage : IntArray, ISolution {
+  public sealed class LinearLinkage : IntArray, IEncodedSolution {
 
     [StorableConstructor]
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs	(revision 16751)
@@ -30,5 +30,5 @@
   [Item("Permutation", "Represents a permutation of integer values.")]
   [StorableType("FBBCFA53-C1AE-4069-907B-99C720F5AC51")]
-  public class Permutation : IntArray, ISolution {
+  public class Permutation : IntArray, IEncodedSolution {
     [Storable]
     private PermutationTypes permutationType;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.RealVectorEncoding/3.3/RealVector.cs	(revision 16751)
@@ -30,5 +30,5 @@
   [StorableType("C4213FB3-77C3-4814-A7A3-0151B0FF5270")]
   [Item("RealVector", "Represents a vector of real values.")]
-  public class RealVector : DoubleArray, ISolution {
+  public class RealVector : DoubleArray, IEncodedSolution {
     [StorableConstructor]
     protected RealVector(StorableConstructorFlag _) : base(_) { }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.ScheduleEncoding/3.3/Interfaces/ISchedule.cs	(revision 16751)
@@ -23,5 +23,5 @@
 
 namespace HeuristicLab.Encodings.ScheduleEncoding {
-  public interface ISchedule : ISolution {
+  public interface ISchedule : IEncodedSolution {
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTree.cs	(revision 16751)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
   [StorableType("433dd098-7813-4226-aa76-a41d63c25f81")]
-  public interface ISymbolicExpressionTree : IItem, ISolution {
+  public interface ISymbolicExpressionTree : IItem, IEncodedSolution {
     ISymbolicExpressionTreeNode Root { get; set; }
     int Length { get; }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedSolution.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedSolution.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/CombinedSolution.cs	(revision 16751)
@@ -22,12 +22,12 @@
 using System;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("CombinedSolution", "A solution that consists of other solutions.")]
   [StorableType("B5ED00CB-E533-4ED6-AB2D-95BF7A654AAD")]
-  public sealed class CombinedSolution : Item, ISolution {
+  public sealed class CombinedSolution : Item, IEncodedSolution {
 
     private CombinedEncoding Encoding { get; set; }
@@ -50,7 +50,7 @@
     }
 
-    public ISolution this[string name] {
-      get { return ScopeUtil.GetSolution(Scope, name); }
-      set { ScopeUtil.CopySolutionToScope(Scope, name, value); }
+    public IEncodedSolution this[string name] {
+      get { return ScopeUtil.GetEncodedSolution(Scope, name); }
+      set { ScopeUtil.CopyEncodedSolutionToScope(Scope, name, value); }
     }
 
@@ -66,6 +66,6 @@
     }
 
-    public TSolution GetSolution<TSolution>(string name) where TSolution : class, ISolution {
-      return (TSolution)ScopeUtil.GetSolution(Scope, name);
+    public TEncodedSolution GetEncodedSolution<TEncodedSolution>(string name) where TEncodedSolution : class, IEncodedSolution {
+      return (TEncodedSolution)ScopeUtil.GetEncodedSolution(Scope, name);
     }
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Encoding.cs	(revision 16751)
@@ -23,15 +23,15 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Encoding", "Base class for describing different encodings.")]
   [StorableType("395B1372-FA54-4649-9EBE-5402A0AA9494")]
-  public abstract class Encoding<TSolution> : ParameterizedNamedItem, IEncoding<TSolution>
-    where TSolution : class,ISolution {
-    public override sealed bool CanChangeName {
+  public abstract class Encoding<TEncodedSolution> : ParameterizedNamedItem, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
+    public sealed override bool CanChangeName {
       get { return false; }
     }
@@ -48,11 +48,11 @@
       get { return encodingOperators; }
       set {
-        if (!value.OfType<ISolutionCreator<TSolution>>().Any())
+        if (!value.OfType<ISolutionCreator<TEncodedSolution>>().Any())
           throw new ArgumentException("The provided operators contain no suitable solution creator");
         encodingOperators.Clear();
         foreach (var op in value) encodingOperators.Add(op);
 
-        ISolutionCreator<TSolution> newSolutionCreator = (ISolutionCreator<TSolution>)encodingOperators.FirstOrDefault(o => o.GetType() == SolutionCreator.GetType()) ??
-                               encodingOperators.OfType<ISolutionCreator<TSolution>>().First();
+        ISolutionCreator<TEncodedSolution> newSolutionCreator = (ISolutionCreator<TEncodedSolution>)encodingOperators.FirstOrDefault(o => o.GetType() == SolutionCreator.GetType()) ??
+                               encodingOperators.OfType<ISolutionCreator<TEncodedSolution>>().First();
         SolutionCreator = newSolutionCreator;
         OnOperatorsChanged();
@@ -67,6 +67,6 @@
       get { return SolutionCreator; }
     }
-    public ISolutionCreator<TSolution> SolutionCreator {
-      get { return (ISolutionCreator<TSolution>)SolutionCreatorParameter.Value; }
+    public ISolutionCreator<TEncodedSolution> SolutionCreator {
+      get { return (ISolutionCreator<TEncodedSolution>)SolutionCreatorParameter.Value; }
       set {
         if (value == null) throw new ArgumentNullException("SolutionCreator must not be null.");
@@ -86,5 +86,5 @@
     }
 
-    protected Encoding(Encoding<TSolution> original, Cloner cloner)
+    protected Encoding(Encoding<TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       encodingOperators = cloner.Clone(original.encodingOperators);
@@ -95,5 +95,5 @@
     protected Encoding(string name)
       : base(name) {
-      Parameters.Add(new ValueParameter<ISolutionCreator<TSolution>>(name + ".SolutionCreator", "The operator to create a solution."));
+      Parameters.Add(new ValueParameter<ISolutionCreator<TEncodedSolution>>(name + ".SolutionCreator", "The operator to create a solution."));
       Parameters.Add(new FixedValueParameter<ReadOnlyItemSet<IOperator>>(name + ".Operators", "The operators that the encoding specifies.", encodingOperators.AsReadOnly()));
 
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodedSolution.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodedSolution.cs	(revision 16751)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodedSolution.cs	(revision 16751)
@@ -0,0 +1,28 @@
+﻿#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.Core;
+
+namespace HeuristicLab.Optimization {
+  public interface IEncodedSolution : IItem { }
+}
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncoding.cs	(revision 16751)
@@ -22,6 +22,6 @@
 using System;
 using System.Collections.Generic;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
@@ -40,7 +40,7 @@
   }
 
-  public interface IEncoding<TSolution> : IEncoding
-    where TSolution : class, ISolution {
-    //new ISolutionCreator<TSolution> SolutionCreator { get; }
+  public interface IEncoding<TEncodedSolution> : IEncoding
+    where TEncodedSolution : class, IEncodedSolution {
+    //new ISolutionCreator<TEncodedSolution> SolutionCreator { get; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IEncodingOperator.cs	(revision 16751)
@@ -20,11 +20,11 @@
 #endregion
 
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("20faaf8b-dd4f-4f0e-a772-4c4dec7fcccb")]
-  public interface IEncodingOperator<TSolution> : IOperator where TSolution : class, ISolution {
-    ILookupParameter<IEncoding<TSolution>> EncodingParameter { get; }
+  public interface IEncodingOperator<TEncodedSolution> : IOperator where TEncodedSolution : class, IEncodedSolution {
+    ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter { get; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblem.cs	(revision 16751)
@@ -23,7 +23,7 @@
 
 namespace HeuristicLab.Optimization {
-  public interface IMultiObjectiveProblem<TEncoding, TSolution> : IProblem<TEncoding, TSolution>, IMultiObjectiveHeuristicOptimizationProblem
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface IMultiObjectiveProblem<TEncoding, TEncodedSolution> : IProblem<TEncoding, TEncodedSolution>, IMultiObjectiveHeuristicOptimizationProblem
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IMultiObjectiveProblemDefinition.cs	(revision 16751)
@@ -20,15 +20,15 @@
 #endregion
 
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("39eacdb5-80a0-425d-902a-00eb3e1d6610")]
-  public interface IMultiObjectiveProblemDefinition<TEncoding, TSolution> : IProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution> : IProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     bool[] Maximization { get; }
-    double[] Evaluate(TSolution individual, IRandom random);
-    void Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
+    double[] Evaluate(TEncodedSolution individual, IRandom random);
+    void Analyze(TEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/IProblemDefinition.cs	(revision 16751)
@@ -24,7 +24,7 @@
 namespace HeuristicLab.Optimization {
   [StorableType("747a3cea-b9ba-4322-a5c2-050cd7e16e2a")]
-  public interface IProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface IProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     TEncoding Encoding { get; }
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblem.cs	(revision 16751)
@@ -24,7 +24,7 @@
 
 namespace HeuristicLab.Optimization {
-  public interface ISingleObjectiveProblem<TEncoding, TSolution> : IProblem<TEncoding, TSolution>, ISingleObjectiveHeuristicOptimizationProblem
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface ISingleObjectiveProblem<TEncoding, TEncodedSolution> : IProblem<TEncoding, TEncodedSolution>, ISingleObjectiveHeuristicOptimizationProblem
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 16751)
@@ -21,16 +21,16 @@
 
 using System.Collections.Generic;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("7ec7bf7e-aaa7-4681-828b-3401cf67e2b3")]
-  public interface ISingleObjectiveProblemDefinition<TEncoding, TSolution> : IProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution> : IProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     bool Maximization { get; }
-    double Evaluate(TSolution solution, IRandom random);
-    void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results, IRandom random);
-    IEnumerable<TSolution> GetNeighbors(TSolution solution, IRandom random);
+    double Evaluate(TEncodedSolution solution, IRandom random);
+    void Analyze(TEncodedSolution[] solutions, double[] qualities, ResultCollection results, IRandom random);
+    IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution solution, IRandom random);
     bool IsBetter(double quality, double bestQuality);
   }
Index: anches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISolution.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/ISolution.cs	(revision 16750)
+++ 	(revision )
@@ -1,33 +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 System.Text;
-using System.Threading.Tasks;
-using HeuristicLab.Core;
-
-namespace HeuristicLab.Optimization {
-  public interface ISolution : IItem { }
-}
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveAnalysisOperator.cs	(revision 16751)
@@ -21,12 +21,12 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("c9325602-3262-48a4-8985-03657fb0b34f")]
-  internal interface IMultiObjectiveAnalysisOperator<TSolution> : IEncodingOperator<TSolution>, IAnalyzer, IMultiObjectiveOperator
-  where TSolution : class, ISolution {
-    Action<TSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  internal interface IMultiObjectiveAnalysisOperator<TEncodedSolution> : IEncodingOperator<TEncodedSolution>, IAnalyzer, IMultiObjectiveOperator
+  where TEncodedSolution : class, IEncodedSolution {
+    Action<TEncodedSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/IMultiObjectiveEvaluationOperator.cs	(revision 16751)
@@ -21,12 +21,12 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("89da568c-70a2-48fb-8e6b-ea078bb6fc3f")]
-  internal interface IMultiObjectiveEvaluationOperator<TSolution> : IMultiObjectiveEvaluator, IEncodingOperator<TSolution>
-  where TSolution : class, ISolution {
-    Func<TSolution, IRandom, double[]> EvaluateFunc { get; set; }
+  internal interface IMultiObjectiveEvaluationOperator<TEncodedSolution> : IMultiObjectiveEvaluator, IEncodingOperator<TEncodedSolution>
+  where TEncodedSolution : class, IEncodedSolution {
+    Func<TEncodedSolution, IRandom, double[]> EvaluateFunc { get; set; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/INeighborBasedOperator.cs	(revision 16751)
@@ -22,12 +22,12 @@
 using System;
 using System.Collections.Generic;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("fda56e0b-9392-4711-9af1-55211bfa24ac")]
-  internal interface INeighborBasedOperator<TSolution> : IEncodingOperator<TSolution>
-  where TSolution : class, ISolution {
-    Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
+  internal interface INeighborBasedOperator<TEncodedSolution> : IEncodingOperator<TEncodedSolution>
+  where TEncodedSolution : class, IEncodedSolution {
+    Func<TEncodedSolution, IRandom, IEnumerable<TEncodedSolution>> GetNeighborsFunc { get; set; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveAnalysisOperator.cs	(revision 16751)
@@ -26,7 +26,7 @@
 namespace HeuristicLab.Optimization {
   [StorableType("9731981c-10c6-4850-9308-a4720ac07da7")]
-  internal interface ISingleObjectiveAnalysisOperator<TSolution> : IEncodingOperator<TSolution>, ISingleObjectiveOperator
-  where TSolution : class, ISolution {
-    Action<TSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+  internal interface ISingleObjectiveAnalysisOperator<TEncodedSolution> : IEncodingOperator<TEncodedSolution>, ISingleObjectiveOperator
+  where TEncodedSolution : class, IEncodedSolution {
+    Action<TEncodedSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Interfaces/internal/ISingleObjectiveEvaluationOperator.cs	(revision 16751)
@@ -26,7 +26,7 @@
 namespace HeuristicLab.Optimization {
   [StorableType("5a9cf334-4815-4f0e-a2f8-f3d4edfcc829")]
-  internal interface ISingleObjectiveEvaluationOperator<TSolution> : ISingleObjectiveEvaluator, IEncodingOperator<TSolution>
-  where TSolution : class, ISolution {
-    Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
+  internal interface ISingleObjectiveEvaluationOperator<TEncodedSolution> : ISingleObjectiveEvaluator, IEncodingOperator<TEncodedSolution>
+  where TEncodedSolution : class, IEncodedSolution {
+    Func<TEncodedSolution, IRandom, double> EvaluateFunc { get; set; }
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveProblem.cs	(revision 16751)
@@ -21,23 +21,23 @@
 
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("6F2EC371-0309-4848-B7B1-C9B9C7E3436F")]
-  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 {
+  public abstract class MultiObjectiveProblem<TEncoding, TEncodedSolution> :
+    Problem<TEncoding, TEncodedSolution, MultiObjectiveEvaluator<TEncodedSolution>>,
+    IMultiObjectiveProblem<TEncoding, TEncodedSolution>,
+    IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
     [StorableConstructor]
     protected MultiObjectiveProblem(StorableConstructorFlag _) : base(_) { }
 
-    protected MultiObjectiveProblem(MultiObjectiveProblem<TEncoding, TSolution> original, Cloner cloner)
+    protected MultiObjectiveProblem(MultiObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       ParameterizeOperators();
@@ -49,5 +49,5 @@
 
       Operators.Add(Evaluator);
-      Operators.Add(new MultiObjectiveAnalyzer<TSolution>());
+      Operators.Add(new MultiObjectiveAnalyzer<TEncodedSolution>());
 
       ParameterizeOperators();
@@ -60,7 +60,7 @@
 
     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 abstract double[] Evaluate(TEncodedSolution individual, IRandom random);
+    public virtual void Analyze(TEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) { }
+
     protected override void OnOperatorsChanged() {
       base.OnOperatorsChanged();
@@ -93,7 +93,7 @@
 
     private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<IMultiObjectiveEvaluationOperator<TSolution>>())
+      foreach (var op in Operators.OfType<IMultiObjectiveEvaluationOperator<TEncodedSolution>>())
         op.EvaluateFunc = Evaluate;
-      foreach (var op in Operators.OfType<IMultiObjectiveAnalysisOperator<TSolution>>())
+      foreach (var op in Operators.OfType<IMultiObjectiveAnalysisOperator<TEncodedSolution>>())
         op.AnalyzeAction = Analyze;
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveAnalyzer.cs	(revision 16751)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28,15 +29,14 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Multi-objective Analyzer", "Calls the Analyze method of the problem definition.")]
   [StorableType("903FE3D1-3179-4EA5-A7E1-63DE26239F9B")]
-  public class MultiObjectiveAnalyzer<TSolution> : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator<TSolution>, IStochasticOperator
-  where TSolution : class, ISolution {
+  public class MultiObjectiveAnalyzer<TEncodedSolution> : SingleSuccessorOperator, IMultiObjectiveAnalysisOperator<TEncodedSolution>, IStochasticOperator
+  where TEncodedSolution : class, IEncodedSolution {
     public bool EnabledByDefault { get { return true; } }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -53,12 +53,12 @@
     }
 
-    public Action<TSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
+    public Action<TEncodedSolution[], double[][], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
     protected MultiObjectiveAnalyzer(StorableConstructorFlag _) : base(_) { }
-    protected MultiObjectiveAnalyzer(MultiObjectiveAnalyzer<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveAnalyzer(MultiObjectiveAnalyzer<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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."));
@@ -66,5 +66,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveAnalyzer<TSolution>(this, cloner);
+      return new MultiObjectiveAnalyzer<TEncodedSolution>(this, cloner);
     }
 
@@ -78,5 +78,5 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var individuals = scopes.Select(s => ScopeUtil.GetSolution(s, encoding)).ToArray();
+      var individuals = scopes.Select(s => ScopeUtil.GetEncodedSolution(s, encoding)).ToArray();
       AnalyzeAction(individuals, QualitiesParameter.ActualValue.Select(x => x.ToArray()).ToArray(), results, random);
       return base.Apply();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/MultiObjectiveEvaluator.cs	(revision 16751)
@@ -21,4 +21,5 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26,11 +27,10 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Multi-objective Evaluator", "Calls the Evaluate method of the problem definition and writes the return value into the scope.")]
   [StorableType("C5605ED8-0ED2-4C7B-97A1-E7EB68A4FDBF")]
-  public class MultiObjectiveEvaluator<TSolution> : InstrumentedOperator, IMultiObjectiveEvaluationOperator<TSolution>, IStochasticOperator
-  where TSolution : class, ISolution {
+  public class MultiObjectiveEvaluator<TEncodedSolution> : InstrumentedOperator, IMultiObjectiveEvaluationOperator<TEncodedSolution>, IStochasticOperator
+  where TEncodedSolution : class, IEncodedSolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -38,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -46,17 +46,17 @@
     }
 
-    public Func<TSolution, IRandom, double[]> EvaluateFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, double[]> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     protected MultiObjectiveEvaluator(StorableConstructorFlag _) : base(_) { }
-    protected MultiObjectiveEvaluator(MultiObjectiveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    protected MultiObjectiveEvaluator(MultiObjectiveEvaluator<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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<TSolution>(this, cloner);
+      return new MultiObjectiveEvaluator<TEncodedSolution>(this, cloner);
     }
 
@@ -64,5 +64,5 @@
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var solution = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
       QualitiesParameter.ActualValue = new DoubleArray(EvaluateFunc(solution, random));
       return base.InstrumentedApply();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/ScopeUtil.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/ScopeUtil.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/ScopeUtil.cs	(revision 16751)
@@ -29,12 +29,12 @@
   public static class ScopeUtil {
 
-    public static TSolution CopySolutionToScope<TSolution>(IScope scope, IEncoding<TSolution> encoding, TSolution solution)
-      where TSolution : class,ISolution {
-      return CopySolutionToScope(scope, encoding.Name, solution);
+    public static TEncodedSolution CopyEncodedSolutionToScope<TEncodedSolution>(IScope scope, IEncoding<TEncodedSolution> encoding, TEncodedSolution solution)
+      where TEncodedSolution : class, IEncodedSolution {
+      return CopyEncodedSolutionToScope(scope, encoding.Name, solution);
     }
 
-    public static TSolution CopySolutionToScope<TSolution>(IScope scope, string name, TSolution solution)
-      where TSolution : class,ISolution {
-      var copy = (TSolution)solution.Clone();
+    public static TEncodedSolution CopyEncodedSolutionToScope<TEncodedSolution>(IScope scope, string name, TEncodedSolution solution)
+      where TEncodedSolution : class, IEncodedSolution {
+      var copy = (TEncodedSolution)solution.Clone();
       if (!scope.Variables.ContainsKey(name)) scope.Variables.Add(new Variable(name, copy));
       else scope.Variables[name].Value = copy;
@@ -42,21 +42,21 @@
     }
 
-    public static TSolution GetSolution<TSolution>(IScope scope, IEncoding<TSolution> encoding)
-      where TSolution : class,ISolution {
+    public static TEncodedSolution GetEncodedSolution<TEncodedSolution>(IScope scope, IEncoding<TEncodedSolution> encoding)
+      where TEncodedSolution : class, IEncodedSolution {
       var name = encoding.Name;
       if (!scope.Variables.ContainsKey(name)) throw new ArgumentException(string.Format(" {0} cannot be found in the provided scope.", name));
-      var value = scope.Variables[name].Value as TSolution;
-      if (value == null) throw new InvalidOperationException(string.Format("Value of {0} is null or not of type {1}.", name, typeof(TSolution).GetPrettyName()));
+      var value = scope.Variables[name].Value as TEncodedSolution;
+      if (value == null) throw new InvalidOperationException(string.Format("Value of {0} is null or not of type {1}.", name, typeof(TEncodedSolution).GetPrettyName()));
       return value;
     }
 
-    public static ISolution GetSolution(IScope scope, IEncoding encoding) {
-      return GetSolution(scope, encoding.Name);
+    public static IEncodedSolution GetEncodedSolution(IScope scope, IEncoding encoding) {
+      return GetEncodedSolution(scope, encoding.Name);
     }
 
-    public static ISolution GetSolution(IScope scope, string name) {
+    public static IEncodedSolution GetEncodedSolution(IScope scope, string name) {
       IVariable variable;
       if (!scope.Variables.TryGetValue(name, out variable)) throw new ArgumentException(string.Format("{0} cannot be found in the provided scope.", name));
-      var solution = variable.Value as ISolution;
+      var solution = variable.Value as IEncodedSolution;
       if (solution == null) throw new InvalidOperationException(string.Format("{0} is null or not of type ISolution.", name));
       return solution;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveAnalyzer.cs	(revision 16751)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -28,15 +29,14 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Single-objective Analyzer", "Calls the script's Analyze method to be able to write into the results collection.")]
   [StorableType("3D20F8E2-CE11-4021-A05B-CFCB02C0FD6F")]
-  public sealed class SingleObjectiveAnalyzer<TSolution> : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator<TSolution>, IAnalyzer, IStochasticOperator
-  where TSolution : class, ISolution {
+  public sealed class SingleObjectiveAnalyzer<TEncodedSolution> : SingleSuccessorOperator, ISingleObjectiveAnalysisOperator<TEncodedSolution>, IAnalyzer, IStochasticOperator
+  where TEncodedSolution : class, IEncodedSolution {
     public bool EnabledByDefault { get { return true; } }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -53,11 +53,11 @@
     }
 
-    public Action<TSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
+    public Action<TEncodedSolution[], double[], ResultCollection, IRandom> AnalyzeAction { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveAnalyzer(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveAnalyzer(SingleObjectiveAnalyzer<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveAnalyzer(SingleObjectiveAnalyzer<TEncodedSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveAnalyzer() {
-      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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."));
@@ -66,5 +66,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveAnalyzer<TSolution>(this, cloner);
+      return new SingleObjectiveAnalyzer<TEncodedSolution>(this, cloner);
     }
 
@@ -78,5 +78,5 @@
         scopes = scopes.Select(x => (IEnumerable<IScope>)x.SubScopes).Aggregate((a, b) => a.Concat(b));
 
-      var individuals = scopes.Select(s => ScopeUtil.GetSolution(s, encoding)).ToArray();
+      var individuals = scopes.Select(s => ScopeUtil.GetEncodedSolution(s, encoding)).ToArray();
       AnalyzeAction(individuals, QualityParameter.ActualValue.Select(x => x.Value).ToArray(), results, random);
       return base.Apply();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveEvaluator.cs	(revision 16751)
@@ -31,6 +31,6 @@
   [Item("Single-objective Evaluator", "Calls the script's Evaluate method to get the quality value of the parameter vector.")]
   [StorableType("E8914B68-D0D7-407F-8D58-002FDF2F45CF")]
-  public sealed class SingleObjectiveEvaluator<TSolution> : InstrumentedOperator, ISingleObjectiveEvaluationOperator<TSolution>, IStochasticOperator
-  where TSolution : class, ISolution {
+  public sealed class SingleObjectiveEvaluator<TEncodedSolution> : InstrumentedOperator, ISingleObjectiveEvaluationOperator<TEncodedSolution>, IStochasticOperator
+  where TEncodedSolution : class, IEncodedSolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -38,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -46,21 +46,21 @@
     }
 
-    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, double> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveEvaluator(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveEvaluator(SingleObjectiveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveEvaluator(SingleObjectiveEvaluator<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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<TSolution>(this, cloner); }
+    public override IDeepCloneable Clone(Cloner cloner) { return new SingleObjectiveEvaluator<TEncodedSolution>(this, cloner); }
 
     public override IOperation InstrumentedApply() {
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var solution = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
       QualityParameter.ActualValue = new DoubleValue(EvaluateFunc(solution, random));
       return base.InstrumentedApply();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveImprover.cs	(revision 16751)
@@ -33,12 +33,12 @@
   [Item("Single-objective Improver", "Improves a solution by calling GetNeighbors and Evaluate of the corresponding problem definition.")]
   [StorableType("7A917E09-920C-4B47-9599-67371101B35F")]
-  public sealed class SingleObjectiveImprover<TSolution> : SingleSuccessorOperator, INeighborBasedOperator<TSolution>, IImprovementOperator, ISingleObjectiveEvaluationOperator<TSolution>, IStochasticOperator
-    where TSolution : class, ISolution {
+  public sealed class SingleObjectiveImprover<TEncodedSolution> : SingleSuccessorOperator, INeighborBasedOperator<TEncodedSolution>, IImprovementOperator, ISingleObjectiveEvaluationOperator<TEncodedSolution>, IStochasticOperator
+    where TEncodedSolution : class, IEncodedSolution {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -63,13 +63,13 @@
     }
 
-    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
-    public Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, IEnumerable<TEncodedSolution>> GetNeighborsFunc { get; set; }
 
     [StorableConstructor]
     private SingleObjectiveImprover(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveImprover(SingleObjectiveImprover<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveImprover(SingleObjectiveImprover<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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."));
@@ -80,5 +80,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveImprover<TSolution>(this, cloner);
+      return new SingleObjectiveImprover<TEncodedSolution>(this, cloner);
     }
 
@@ -89,10 +89,10 @@
       var maxAttempts = ImprovementAttemptsParameter.ActualValue.Value;
       var sampleSize = SampleSizeParameter.ActualValue.Value;
-      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var solution = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
       var quality = QualityParameter.ActualValue == null ? EvaluateFunc(solution, random) : QualityParameter.ActualValue.Value;
 
       var count = 0;
       for (var i = 0; i < maxAttempts; i++) {
-        TSolution best = default(TSolution);
+        TEncodedSolution best = default(TEncodedSolution);
         var bestQuality = quality;
         foreach (var neighbor in GetNeighborsFunc(solution, random).Take(sampleSize)) {
@@ -111,5 +111,5 @@
       QualityParameter.ActualValue = new DoubleValue(quality);
 
-      ScopeUtil.CopySolutionToScope(ExecutionContext.Scope, encoding, solution);
+      ScopeUtil.CopyEncodedSolutionToScope(ExecutionContext.Scope, encoding, solution);
       return base.Apply();
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveEvaluator.cs	(revision 16751)
@@ -21,4 +21,5 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26,11 +27,10 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Single-objective MoveEvaluator", "Evaluates a parameter vector that results from a move.")]
   [StorableType("EE4B1EBA-50BF-40C7-B338-F4A9D9CC554E")]
-  public class SingleObjectiveMoveEvaluator<TSolution> : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator<TSolution>, ISingleObjectiveMoveEvaluator, IStochasticOperator, ISingleObjectiveMoveOperator
-  where TSolution : class, ISolution {
+  public class SingleObjectiveMoveEvaluator<TEncodedSolution> : SingleSuccessorOperator, ISingleObjectiveEvaluationOperator<TEncodedSolution>, ISingleObjectiveMoveEvaluator, IStochasticOperator, ISingleObjectiveMoveOperator
+  where TEncodedSolution : class, IEncodedSolution {
 
     public ILookupParameter<IRandom> RandomParameter {
@@ -38,6 +38,6 @@
     }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -50,12 +50,12 @@
     }
 
-    public Func<TSolution, IRandom, double> EvaluateFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, double> EvaluateFunc { get; set; }
 
     [StorableConstructor]
     protected SingleObjectiveMoveEvaluator(StorableConstructorFlag _) : base(_) { }
-    protected SingleObjectiveMoveEvaluator(SingleObjectiveMoveEvaluator<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveMoveEvaluator(SingleObjectiveMoveEvaluator<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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."));
@@ -63,5 +63,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveEvaluator<TSolution>(this, cloner);
+      return new SingleObjectiveMoveEvaluator<TEncodedSolution>(this, cloner);
     }
 
@@ -69,5 +69,5 @@
       var random = RandomParameter.ActualValue;
       var encoding = EncodingParameter.ActualValue;
-      var individual = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var individual = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
       MoveQualityParameter.ActualValue = new DoubleValue(EvaluateFunc(individual, random));
       return base.Apply();
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveGenerator.cs	(revision 16751)
@@ -34,6 +34,6 @@
   [Item("Single-objective MoveGenerator", "Calls the GetNeighbors method of the problem definition to obtain the moves.")]
   [StorableType("CB37E7D8-EAC3-4061-9D39-20538CD1064D")]
-  public class SingleObjectiveMoveGenerator<TSolution> : SingleSuccessorOperator, INeighborBasedOperator<TSolution>, IMultiMoveGenerator, IStochasticOperator, ISingleObjectiveMoveOperator
-  where TSolution : class, ISolution {
+  public class SingleObjectiveMoveGenerator<TEncodedSolution> : SingleSuccessorOperator, INeighborBasedOperator<TEncodedSolution>, IMultiMoveGenerator, IStochasticOperator, ISingleObjectiveMoveOperator
+  where TEncodedSolution : class, IEncodedSolution {
     public ILookupParameter<IRandom> RandomParameter {
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
@@ -44,22 +44,22 @@
     }
 
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
-    public Func<TSolution, IRandom, IEnumerable<TSolution>> GetNeighborsFunc { get; set; }
+    public Func<TEncodedSolution, IRandom, IEnumerable<TEncodedSolution>> GetNeighborsFunc { get; set; }
 
     [StorableConstructor]
     protected SingleObjectiveMoveGenerator(StorableConstructorFlag _) : base(_) { }
-    protected SingleObjectiveMoveGenerator(SingleObjectiveMoveGenerator<TSolution> original, Cloner cloner)
+    protected SingleObjectiveMoveGenerator(SingleObjectiveMoveGenerator<TEncodedSolution> 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<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("Encoding", "An item that holds the problem's encoding."));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveGenerator<TSolution>(this, cloner);
+      return new SingleObjectiveMoveGenerator<TEncodedSolution>(this, cloner);
     }
 
@@ -68,5 +68,5 @@
       var sampleSize = SampleSizeParameter.ActualValue.Value;
       var encoding = EncodingParameter.ActualValue;
-      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
+      var solution = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
       var nbhood = GetNeighborsFunc(solution, random).Take(sampleSize).ToList();
 
@@ -74,5 +74,5 @@
       for (int i = 0; i < moveScopes.Length; i++) {
         moveScopes[i] = new Scope(i.ToString(CultureInfo.InvariantCulture.NumberFormat));
-        ScopeUtil.CopySolutionToScope(moveScopes[i], encoding, nbhood[i]);
+        ScopeUtil.CopyEncodedSolutionToScope(moveScopes[i], encoding, nbhood[i]);
       }
       ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Operators/SingleObjectiveMoveMaker.cs	(revision 16751)
@@ -21,4 +21,5 @@
 
 using System;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26,13 +27,12 @@
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [Item("Single-objective MoveMaker", "Applies a move.")]
   [StorableType("C0ABF392-C825-4B98-8FB9-5749A9091FD6")]
-  public class SingleObjectiveMoveMaker<TSolution> : InstrumentedOperator, IMoveMaker, ISingleObjectiveMoveOperator
-  where TSolution : class, ISolution {
-    public ILookupParameter<IEncoding<TSolution>> EncodingParameter {
-      get { return (ILookupParameter<IEncoding<TSolution>>)Parameters["Encoding"]; }
+  public class SingleObjectiveMoveMaker<TEncodedSolution> : InstrumentedOperator, IMoveMaker, ISingleObjectiveMoveOperator
+  where TEncodedSolution : class, IEncodedSolution {
+    public ILookupParameter<IEncoding<TEncodedSolution>> EncodingParameter {
+      get { return (ILookupParameter<IEncoding<TEncodedSolution>>)Parameters["Encoding"]; }
     }
 
@@ -47,7 +47,7 @@
     [StorableConstructor]
     protected SingleObjectiveMoveMaker(StorableConstructorFlag _) : base(_) { }
-    protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker<TSolution> original, Cloner cloner) : base(original, cloner) { }
+    protected SingleObjectiveMoveMaker(SingleObjectiveMoveMaker<TEncodedSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveMoveMaker() {
-      Parameters.Add(new LookupParameter<IEncoding<TSolution>>("Encoding", "An item that holds the problem's encoding."));
+      Parameters.Add(new LookupParameter<IEncoding<TEncodedSolution>>("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."));
@@ -55,5 +55,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveMoveMaker<TSolution>(this, cloner);
+      return new SingleObjectiveMoveMaker<TEncodedSolution>(this, cloner);
     }
 
@@ -62,6 +62,6 @@
 
       var encoding = EncodingParameter.ActualValue;
-      var solution = ScopeUtil.GetSolution(ExecutionContext.Scope, encoding);
-      ScopeUtil.CopySolutionToScope(ExecutionContext.Scope.Parent.Parent, encoding, solution);
+      var solution = ScopeUtil.GetEncodedSolution(ExecutionContext.Scope, encoding);
+      ScopeUtil.CopyEncodedSolutionToScope(ExecutionContext.Scope.Parent.Parent, encoding, solution);
 
       if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/Problem.cs	(revision 16751)
@@ -23,20 +23,20 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("D877082E-9E77-4CB1-ABDB-35F63878E116")]
-  public abstract class Problem<TEncoding, TSolution, TEvaluator> : Problem,
-    IHeuristicOptimizationProblem, IProblemDefinition<TEncoding, TSolution>, IStorableContent
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution
+  public abstract class Problem<TEncoding, TEncodedSolution, TEvaluator> : Problem,
+    IHeuristicOptimizationProblem, IProblemDefinition<TEncoding, TEncodedSolution>, IStorableContent
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution
     where TEvaluator : class, IEvaluator {
 
     public string Filename { get; set; } // TODO: Really okay here? should be in Problem (non-generic)
 
-    //TODO remove parametr for encoding?
+    //TODO remove parameter for encoding?
     protected IValueParameter<TEncoding> EncodingParameter {
       get { return (IValueParameter<TEncoding>)Parameters["Encoding"]; }
@@ -115,5 +115,5 @@
     }
 
-    protected Problem(Problem<TEncoding, TSolution, TEvaluator> original, Cloner cloner)
+    protected Problem(Problem<TEncoding, TEncodedSolution, TEvaluator> original, Cloner cloner)
       : base(original, cloner) {
       oldEncoding = cloner.Clone(original.oldEncoding);
@@ -152,5 +152,5 @@
       oldEncoding = Encoding;
 
-      foreach (var op in Operators.OfType<IEncodingOperator<TSolution>>())
+      foreach (var op in Operators.OfType<IEncodingOperator<TEncodedSolution>>())
         op.EncodingParameter.ActualName = EncodingParameter.Name;
 
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/BasicProblems/SingleObjectiveProblem.cs	(revision 16751)
@@ -23,18 +23,18 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
   [StorableType("2697320D-0259-44BB-BD71-7EE1B10F664C")]
-  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 {
+  public abstract class SingleObjectiveProblem<TEncoding, TEncodedSolution> :
+    Problem<TEncoding, TEncodedSolution, SingleObjectiveEvaluator<TEncodedSolution>>,
+    ISingleObjectiveProblem<TEncoding, TEncodedSolution>,
+    ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
     protected IValueParameter<DoubleValue> BestKnownQualityParameter {
@@ -64,5 +64,5 @@
     protected SingleObjectiveProblem(StorableConstructorFlag _) : base(_) { }
 
-    protected SingleObjectiveProblem(SingleObjectiveProblem<TEncoding, TSolution> original, Cloner cloner)
+    protected SingleObjectiveProblem(SingleObjectiveProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       ParameterizeOperators();
@@ -75,9 +75,9 @@
 
       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>());
+      Operators.Add(new SingleObjectiveAnalyzer<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveImprover<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveEvaluator<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveGenerator<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveMaker<TEncodedSolution>());
 
       ParameterizeOperators();
@@ -90,9 +90,9 @@
 
       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>());
+      Operators.Add(new SingleObjectiveAnalyzer<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveImprover<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveEvaluator<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveGenerator<TEncodedSolution>());
+      Operators.Add(new SingleObjectiveMoveMaker<TEncodedSolution>());
 
       ParameterizeOperators();
@@ -105,8 +105,8 @@
 
     public abstract bool Maximization { get; }
-    public abstract double Evaluate(TSolution solution, IRandom random);
-    public virtual void Analyze(TSolution[] solutions, double[] qualities, ResultCollection results, IRandom random) { }
-    public virtual IEnumerable<TSolution> GetNeighbors(TSolution solution, IRandom random) {
-      return Enumerable.Empty<TSolution>();
+    public abstract double Evaluate(TEncodedSolution solution, IRandom random);
+    public virtual void Analyze(TEncodedSolution[] solutions, double[] qualities, ResultCollection results, IRandom random) { }
+    public virtual IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution solution, IRandom random) {
+      return Enumerable.Empty<TEncodedSolution>();
     }
 
@@ -115,8 +115,8 @@
     }
 
-    protected Tuple<TSolution, double> GetBestSolution(TSolution[] solutions, double[] qualities) {
+    protected Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities) {
       return GetBestSolution(solutions, qualities, Maximization);
     }
-    public static Tuple<TSolution, double> GetBestSolution(TSolution[] solutions, double[] qualities, bool maximization) {
+    public static Tuple<TEncodedSolution, double> GetBestSolution(TEncodedSolution[] solutions, double[] qualities, bool maximization) {
       var zipped = solutions.Zip(qualities, (s, q) => new { Solution = s, Quality = q });
       var best = (maximization ? zipped.OrderByDescending(z => z.Quality) : zipped.OrderBy(z => z.Quality)).First();
@@ -154,9 +154,9 @@
 
     private void ParameterizeOperators() {
-      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator<TSolution>>())
+      foreach (var op in Operators.OfType<ISingleObjectiveEvaluationOperator<TEncodedSolution>>())
         op.EvaluateFunc = Evaluate;
-      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator<TSolution>>())
+      foreach (var op in Operators.OfType<ISingleObjectiveAnalysisOperator<TEncodedSolution>>())
         op.AnalyzeAction = Analyze;
-      foreach (var op in Operators.OfType<INeighborBasedOperator<TSolution>>())
+      foreach (var op in Operators.OfType<INeighborBasedOperator<TEncodedSolution>>())
         op.GetNeighborsFunc = GetNeighbors;
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/HeuristicLab.Optimization-3.3.csproj	(revision 16751)
@@ -143,5 +143,5 @@
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveMoveOperator.cs" />
     <Compile Include="BasicProblems\Interfaces\ISingleObjectiveProblemDefinition.cs" />
-    <Compile Include="BasicProblems\Interfaces\ISolution.cs" />
+    <Compile Include="BasicProblems\Interfaces\IEncodedSolution.cs" />
     <Compile Include="BasicProblems\MultiObjectiveProblem.cs" />
     <Compile Include="BasicProblems\Operators\MultiObjectiveAnalyzer.cs" />
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/IProblem.cs	(revision 16751)
@@ -22,6 +22,6 @@
 using System;
 using System.Collections.Generic;
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
@@ -38,7 +38,7 @@
   }
 
-  public interface IProblem<TEncoding, TSolution> : IHeuristicOptimizationProblem
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public interface IProblem<TEncoding, TEncodedSolution> : IHeuristicOptimizationProblem
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Optimization/3.3/Interfaces/ISolutionCreator.cs	(revision 16751)
@@ -20,6 +20,6 @@
 #endregion
 
+using HEAL.Attic;
 using HeuristicLab.Core;
-using HEAL.Attic;
 
 namespace HeuristicLab.Optimization {
@@ -30,6 +30,6 @@
   public interface ISolutionCreator : IOperator { }
 
-  public interface ISolutionCreator<TSolution> : ISolutionCreator where TSolution : class, ISolution {
-    //ILookupParameter<TSolution> SolutionParameter { get; } // TODO: unify encoding specific parameters by defining ISolutionOperator and ISolutionsOperator
+  public interface ISolutionCreator<TEncodedSolution> : ISolutionCreator where TEncodedSolution : class, IEncodedSolution {
+    //ILookupParameter<TEncodedSolution> SolutionParameter { get; } // TODO: unify encoding specific parameters by defining ISolutionOperator and ISolutionsOperator
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/ExternalEvaluationProblem.cs	(revision 16751)
@@ -40,5 +40,5 @@
   // BackwardsCompatibility3.3
   // Rename class to SingleObjectiveExternalEvaluationProblem
-  public class ExternalEvaluationProblem : SingleObjectiveProblem<IEncoding<ISolution>, ISolution>, IExternalEvaluationProblem {
+  public class ExternalEvaluationProblem : SingleObjectiveProblem<IEncoding<IEncodedSolution>, IEncodedSolution>, IExternalEvaluationProblem {
 
     public static new Image StaticItemImage {
@@ -66,5 +66,5 @@
 
     #region Properties
-    public new IEncoding<ISolution> Encoding {
+    public new IEncoding<IEncodedSolution> Encoding {
       get { return base.Encoding; }
       set { base.Encoding = value; }
@@ -114,5 +114,5 @@
     }
 
-    public override double Evaluate(ISolution individual, IRandom random) {
+    public override double Evaluate(IEncodedSolution individual, IRandom random) {
       var qualityMessage = Evaluate(BuildSolutionMessage(individual));
       if (!qualityMessage.HasExtension(SingleObjectiveQualityMessage.QualityMessage_))
@@ -126,9 +126,9 @@
     }
 
-    public override void Analyze(ISolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    public override void Analyze(IEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       OptimizationSupport.Analyze(individuals, qualities, results, random);
     }
 
-    public override IEnumerable<ISolution> GetNeighbors(ISolution individual, IRandom random) {
+    public override IEnumerable<IEncodedSolution> GetNeighbors(IEncodedSolution individual, IRandom random) {
       return OptimizationSupport.GetNeighbors(individual, random);
     }
@@ -167,10 +167,10 @@
     }
 
-    private SolutionMessage BuildSolutionMessage(ISolution solution, int solutionId = 0) {
+    private SolutionMessage BuildSolutionMessage(IEncodedSolution solution, int solutionId = 0) {
       lock (clientLock) {
         SolutionMessage.Builder protobufBuilder = SolutionMessage.CreateBuilder();
         protobufBuilder.SolutionId = solutionId;
         var scope = new Scope();
-        ScopeUtil.CopySolutionToScope(scope, Encoding, solution);
+        ScopeUtil.CopyEncodedSolutionToScope(scope, Encoding, solution);
         foreach (var variable in scope.Variables) {
           try {
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/IMultiObjectiveOptimizationSupport.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/IMultiObjectiveOptimizationSupport.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/IMultiObjectiveOptimizationSupport.cs	(revision 16751)
@@ -27,5 +27,5 @@
   [StorableType("f924ef9c-d824-40d2-89b2-6dd1220df98b")]
   public interface IMultiObjectiveOptimizationSupport {
-    void Analyze(ISolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
+    void Analyze(IEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/ISingleObjectiveOptimizationSupport.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/ISingleObjectiveOptimizationSupport.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Interfaces/ISingleObjectiveOptimizationSupport.cs	(revision 16751)
@@ -28,6 +28,6 @@
   [StorableType("09d522e0-c10f-474c-b7c0-7d7f98e63f44")]
   public interface ISingleObjectiveOptimizationSupport {
-    void Analyze(ISolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
-    IEnumerable<ISolution> GetNeighbors(ISolution individual, IRandom random);
+    void Analyze(IEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
+    IEnumerable<IEncodedSolution> GetNeighbors(IEncodedSolution individual, IRandom random);
   }
 }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/MultiObjectiveExternalEvaluationProblem.cs	(revision 16751)
@@ -37,5 +37,5 @@
   [Creatable(CreatableAttribute.Categories.ExternalEvaluationProblems, Priority = 200)]
   [StorableType("CCA50199-A6AB-4C84-B4FA-0262CAF416EC")]
-  public class MultiObjectiveExternalEvaluationProblem : MultiObjectiveProblem<IEncoding<ISolution>, ISolution>, IExternalEvaluationProblem {
+  public class MultiObjectiveExternalEvaluationProblem : MultiObjectiveProblem<IEncoding<IEncodedSolution>, IEncodedSolution>, IExternalEvaluationProblem {
 
     public static new Image StaticItemImage {
@@ -63,5 +63,5 @@
 
     #region Properties
-    public new IEncoding<ISolution> Encoding {
+    public new IEncoding<IEncodedSolution> Encoding {
       get { return base.Encoding; }
       set { base.Encoding = value; }
@@ -114,5 +114,5 @@
     }
 
-    public override double[] Evaluate(ISolution individual, IRandom random) {
+    public override double[] Evaluate(IEncodedSolution individual, IRandom random) {
       var qualityMessage = Evaluate(BuildSolutionMessage(individual));
       if (!qualityMessage.HasExtension(MultiObjectiveQualityMessage.QualityMessage_))
@@ -126,5 +126,5 @@
     }
 
-    public override void Analyze(ISolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+    public override void Analyze(IEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
       OptimizationSupport.Analyze(individuals, qualities, results, random);
     }
@@ -164,10 +164,10 @@
     }
 
-    private SolutionMessage BuildSolutionMessage(ISolution solution, int solutionId = 0) {
+    private SolutionMessage BuildSolutionMessage(IEncodedSolution solution, int solutionId = 0) {
       lock (clientLock) {
         SolutionMessage.Builder protobufBuilder = SolutionMessage.CreateBuilder();
         protobufBuilder.SolutionId = solutionId;
         var scope = new Scope();
-        ScopeUtil.CopySolutionToScope(scope, Encoding, solution);
+        ScopeUtil.CopyEncodedSolutionToScope(scope, Encoding, solution);
         foreach (var variable in scope.Variables) {
           try {
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledMultiObjectiveOptimizationSupport.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledMultiObjectiveOptimizationSupport.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledMultiObjectiveOptimizationSupport.cs	(revision 16751)
@@ -5,5 +5,5 @@
   public class CompiledMultiObjectiveOptimizationSupport : CompiledOptimizationSupport, IMultiObjectiveOptimizationSupport {
 
-    public void Analyze(ISolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+    public void Analyze(IEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Write or update results given the range of vectors and resulting qualities
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledSingleObjectiveOptimizationSupport.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledSingleObjectiveOptimizationSupport.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/CompiledSingleObjectiveOptimizationSupport.cs	(revision 16751)
@@ -6,5 +6,5 @@
   public class CompiledSingleObjectiveOptimizationSupport : CompiledOptimizationSupport, ISingleObjectiveOptimizationSupport {
 
-    public void Analyze(ISolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    public void Analyze(IEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Write or update results given the range of vectors and resulting qualities
@@ -17,5 +17,5 @@
     }
 
-    public IEnumerable<ISolution> GetNeighbors(ISolution individual, IRandom random) {
+    public IEnumerable<IEncodedSolution> GetNeighbors(IEncodedSolution individual, IRandom random) {
       // Use vars.yourVariable to access variables in the variable store i.e. yourVariable
       // Create new vectors, based on the given one that represent small changes
@@ -24,5 +24,5 @@
         // Algorithm will draw only a finite amount of samples
         // Change to a for-loop to return a concrete amount of neighbors
-        var neighbor = (ISolution)individual.Clone();
+        var neighbor = (IEncodedSolution)individual.Clone();
         // For instance, perform a single bit-flip in a binary parameter
         //var bIndex = random.Next(neighbor.BinaryVector("b").Length);
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/MultiObjectiveOptimizationSupportScript.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/MultiObjectiveOptimizationSupportScript.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/MultiObjectiveOptimizationSupportScript.cs	(revision 16751)
@@ -39,5 +39,5 @@
     }
 
-    void IMultiObjectiveOptimizationSupport.Analyze(ISolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+    void IMultiObjectiveOptimizationSupport.Analyze(IEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
       CompiledInstance.Analyze(individuals, qualities, results, random);
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/SingleObjectiveOptimizationSupportScript.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/SingleObjectiveOptimizationSupportScript.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.ExternalEvaluation/3.4/Programmable/SingleObjectiveOptimizationSupportScript.cs	(revision 16751)
@@ -40,9 +40,9 @@
     }
 
-    void ISingleObjectiveOptimizationSupport.Analyze(ISolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    void ISingleObjectiveOptimizationSupport.Analyze(IEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       CompiledInstance.Analyze(individuals, qualities, results, random);
     }
 
-    IEnumerable<ISolution> ISingleObjectiveOptimizationSupport.GetNeighbors(ISolution individual, IRandom random) {
+    IEnumerable<IEncodedSolution> ISingleObjectiveOptimizationSupport.GetNeighbors(IEncodedSolution individual, IRandom random) {
       return CompiledInstance.GetNeighbors(individual, random);
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/CompiledProblemDefinition.cs	(revision 16751)
@@ -26,7 +26,7 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public abstract class CompiledProblemDefinition<TEncoding, TSolution> : IProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public abstract class CompiledProblemDefinition<TEncoding, TEncodedSolution> : IProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     private TEncoding encoding;
     public TEncoding Encoding {
@@ -48,7 +48,7 @@
   }
 
-  public abstract class CompiledSingleObjectiveProblemDefinition<TEncoding, TSolution> : CompiledProblemDefinition<TEncoding, TSolution>, ISingleObjectiveProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public abstract class CompiledSingleObjectiveProblemDefinition<TEncoding, TEncodedSolution> : CompiledProblemDefinition<TEncoding, TEncodedSolution>, ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
     protected CompiledSingleObjectiveProblemDefinition() : base() { }
@@ -57,9 +57,9 @@
       : base(encoding) { }
 
-    #region ISingleObjectiveProblemDefinition<TEncoding,TSolution> Members
+    #region ISingleObjectiveProblemDefinition<TEncoding,TEncodedSolution> Members
     public abstract bool Maximization { get; }
-    public abstract double Evaluate(TSolution individual, IRandom random);
-    public abstract void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
-    public abstract IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
+    public abstract double Evaluate(TEncodedSolution individual, IRandom random);
+    public abstract void Analyze(TEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random);
+    public abstract IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution individual, IRandom random);
 
     public bool IsBetter(double quality, double bestQuality) {
@@ -69,7 +69,7 @@
   }
 
-  public abstract class CompiledMultiObjectiveProblemDefinition<TEncoding, TSolution> : CompiledProblemDefinition<TEncoding, TSolution>, IMultiObjectiveProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public abstract class CompiledMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution> : CompiledProblemDefinition<TEncoding, TEncodedSolution>, IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
     protected CompiledMultiObjectiveProblemDefinition() : base() { }
@@ -78,9 +78,9 @@
       : base(encoding) { }
 
-    #region ISingleObjectiveProblemDefinition<TEncoding,TSolution> Members
+    #region ISingleObjectiveProblemDefinition<TEncoding,TEncodedSolution> Members
     public abstract bool[] Maximization { get; }
-    public abstract double[] Evaluate(TSolution individual, IRandom random);
-    public abstract void Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
-    public abstract IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random);
+    public abstract double[] Evaluate(TEncodedSolution individual, IRandom random);
+    public abstract void Analyze(TEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random);
+    public abstract IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution individual, IRandom random);
     #endregion
   }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProblemDefinitionScript.cs	(revision 16751)
@@ -20,40 +20,40 @@
 #endregion
 
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
-using HEAL.Attic;
 
 namespace HeuristicLab.Problems.Programmable {
   [Item("Multi-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableType("17741D64-CF9D-4CCF-9892-0590C325D4E6")]
-  public sealed class MultiObjectiveProblemDefinitionScript<TEncoding, TSolution> : ProblemDefinitionScript<TEncoding, TSolution>, IMultiObjectiveProblemDefinition<TEncoding, TSolution>, IStorableContent
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public sealed class MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> : ProblemDefinitionScript<TEncoding, TEncodedSolution>, IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>, IStorableContent
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     public string Filename { get; set; }
 
-    private new IMultiObjectiveProblemDefinition<TEncoding, TSolution> CompiledProblemDefinition {
-      get { return (IMultiObjectiveProblemDefinition<TEncoding, TSolution>)base.CompiledProblemDefinition; }
+    private new IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution> CompiledProblemDefinition {
+      get { return (IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>)base.CompiledProblemDefinition; }
     }
 
     [StorableConstructor]
     private MultiObjectiveProblemDefinitionScript(StorableConstructorFlag _) : base(_) { }
-    private MultiObjectiveProblemDefinitionScript(MultiObjectiveProblemDefinitionScript<TEncoding, TSolution> original, Cloner cloner) : base(original, cloner) { }
+    private MultiObjectiveProblemDefinitionScript(MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> original, Cloner cloner) : base(original, cloner) { }
     public MultiObjectiveProblemDefinitionScript(string codeTemplate) : base(codeTemplate) { }
     public MultiObjectiveProblemDefinitionScript() : base() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveProblemDefinitionScript<TEncoding, TSolution>(this, cloner);
+      return new MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>(this, cloner);
     }
 
-    bool[] IMultiObjectiveProblemDefinition<TEncoding, TSolution>.Maximization {
+    bool[] IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Maximization {
       get { return CompiledProblemDefinition.Maximization; }
     }
 
-    double[] IMultiObjectiveProblemDefinition<TEncoding, TSolution>.Evaluate(TSolution individual, IRandom random) {
+    double[] IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Evaluate(TEncodedSolution individual, IRandom random) {
       return CompiledProblemDefinition.Evaluate(individual, random);
     }
 
-    void IMultiObjectiveProblemDefinition<TEncoding, TSolution>.Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+    void IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Analyze(TEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
       CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/MultiObjectiveProgrammableProblem.cs	(revision 16751)
@@ -34,7 +34,7 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 120)]
   [StorableType("1AA24077-4E1E-4FAE-8EC8-B6008DFD30B9")]
-  public class MultiObjectiveProgrammableProblem<TEncoding, TSolution> : MultiObjectiveProblem<TEncoding, TSolution>, IProgrammableItem, IProgrammableProblem
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public class MultiObjectiveProgrammableProblem<TEncoding, TEncodedSolution> : MultiObjectiveProblem<TEncoding, TEncodedSolution>, IProgrammableItem, IProgrammableProblem
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     protected static readonly string ENCODING_NAMESPACE = "ENCODING_NAMESPACE";
     protected static readonly string ENCODING_CLASS = "ENCODING_CLASS";
@@ -45,6 +45,6 @@
     }
 
-    private FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TSolution>> MultiObjectiveProblemScriptParameter {
-      get { return (FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TSolution>>)Parameters["ProblemScript"]; }
+    private FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>> MultiObjectiveProblemScriptParameter {
+      get { return (FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>>)Parameters["ProblemScript"]; }
     }
 
@@ -52,9 +52,9 @@
       get { return ProblemScript; }
     }
-    public MultiObjectiveProblemDefinitionScript<TEncoding, TSolution> ProblemScript {
+    public MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> ProblemScript {
       get { return MultiObjectiveProblemScriptParameter.Value; }
     }
 
-    public IMultiObjectiveProblemDefinition<TEncoding, TSolution> ProblemDefinition {
+    public IMultiObjectiveProblemDefinition<TEncoding, TEncodedSolution> ProblemDefinition {
       get { return MultiObjectiveProblemScriptParameter.Value; }
     }
@@ -62,5 +62,5 @@
     [StorableConstructor]
     protected MultiObjectiveProgrammableProblem(StorableConstructorFlag _) : base(_) { }
-    protected MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem<TEncoding, TSolution> original, Cloner cloner)
+    protected MultiObjectiveProgrammableProblem(MultiObjectiveProgrammableProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
@@ -68,11 +68,11 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new MultiObjectiveProgrammableProblem<TEncoding, TSolution>(this, cloner);
+      return new MultiObjectiveProgrammableProblem<TEncoding, TEncodedSolution>(this, cloner);
     }
 
     public MultiObjectiveProgrammableProblem()
       : base() {
-      Parameters.Add(new FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TSolution>>("ProblemScript", "Defines the problem.",
-        new MultiObjectiveProblemDefinitionScript<TEncoding, TSolution>() { Name = Name }));
+      Parameters.Add(new FixedValueParameter<MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>>("ProblemScript", "Defines the problem.",
+        new MultiObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>() { Name = Name }));
       ProblemScript.Encoding = (TEncoding)Encoding.Clone();
 
@@ -80,5 +80,5 @@
       codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, typeof(TEncoding).Namespace);
       codeTemplate = codeTemplate.Replace(ENCODING_CLASS, typeof(TEncoding).Name);
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, typeof(TSolution).Name);
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, typeof(TEncodedSolution).Name);
       ProblemScript.Code = codeTemplate;
 
@@ -116,9 +116,9 @@
     }
 
-    public override double[] Evaluate(TSolution individual, IRandom random) {
+    public override double[] Evaluate(TEncodedSolution individual, IRandom random) {
       return ProblemDefinition.Evaluate(individual, random);
     }
 
-    public override void Analyze(TSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
+    public override void Analyze(TEncodedSolution[] individuals, double[][] qualities, ResultCollection results, IRandom random) {
       ProblemDefinition.Analyze(individuals, qualities, results, random);
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/ProblemDefinitionScript.cs	(revision 16751)
@@ -56,7 +56,7 @@
   [Item("ProblemDefinitionScript", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableType("0B3AF22C-4744-4860-BBCF-A92046000847")]
-  public abstract class ProblemDefinitionScript<TEncoding, TSolution> : ProblemDefinitionScript, IProblemDefinition<TEncoding, TSolution>
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public abstract class ProblemDefinitionScript<TEncoding, TEncodedSolution> : ProblemDefinitionScript, IProblemDefinition<TEncoding, TEncodedSolution>
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
 
     [Storable]
@@ -70,5 +70,5 @@
     }
 
-    TEncoding IProblemDefinition<TEncoding, TSolution>.Encoding {
+    TEncoding IProblemDefinition<TEncoding, TEncodedSolution>.Encoding {
       get { return Encoding; }
     }
@@ -80,5 +80,5 @@
     [StorableConstructor]
     protected ProblemDefinitionScript(StorableConstructorFlag _) : base(_) { }
-    protected ProblemDefinitionScript(ProblemDefinitionScript<TEncoding, TSolution> original, Cloner cloner)
+    protected ProblemDefinitionScript(ProblemDefinitionScript<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       encoding = cloner.Clone(original.encoding);
@@ -93,6 +93,6 @@
 
     private readonly object compileLock = new object();
-    private volatile CompiledProblemDefinition<TEncoding, TSolution> compiledProblemDefinition;
-    protected CompiledProblemDefinition<TEncoding, TSolution> CompiledProblemDefinition {
+    private volatile CompiledProblemDefinition<TEncoding, TEncodedSolution> compiledProblemDefinition;
+    protected CompiledProblemDefinition<TEncoding, TEncodedSolution> CompiledProblemDefinition {
       get {
         // double checked locking pattern
@@ -119,12 +119,12 @@
       var assembly = base.Compile();
       var types = assembly.GetTypes();
-      if (!types.Any(x => typeof(CompiledProblemDefinition<TEncoding, TSolution>).IsAssignableFrom(x)))
+      if (!types.Any(x => typeof(CompiledProblemDefinition<TEncoding, TEncodedSolution>).IsAssignableFrom(x)))
         throw new ProblemDefinitionScriptException("The compiled code doesn't contain a problem definition." + Environment.NewLine + "The problem definition must be a subclass of CompiledProblemDefinition.");
-      if (types.Count(x => typeof(CompiledProblemDefinition<TEncoding, TSolution>).IsAssignableFrom(x)) > 1)
+      if (types.Count(x => typeof(CompiledProblemDefinition<TEncoding, TEncodedSolution>).IsAssignableFrom(x)) > 1)
         throw new ProblemDefinitionScriptException("The compiled code contains multiple problem definitions." + Environment.NewLine + "Only one subclass of CompiledProblemDefinition is allowed.");
 
-      CompiledProblemDefinition<TEncoding, TSolution> inst;
+      CompiledProblemDefinition<TEncoding, TEncodedSolution> inst;
       try {
-        inst = (CompiledProblemDefinition<TEncoding, TSolution>)Activator.CreateInstance(types.Single(x => typeof(CompiledProblemDefinition<TEncoding, TSolution>).IsAssignableFrom(x)));
+        inst = (CompiledProblemDefinition<TEncoding, TEncodedSolution>)Activator.CreateInstance(types.Single(x => typeof(CompiledProblemDefinition<TEncoding, TEncodedSolution>).IsAssignableFrom(x)));
       } catch (Exception e) {
         compiledProblemDefinition = null;
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProblemDefinitionScript.cs	(revision 16751)
@@ -21,47 +21,47 @@
 
 using System.Collections.Generic;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Optimization;
-using HEAL.Attic;
 
 namespace HeuristicLab.Problems.Programmable {
   [Item("Single-objective Problem Definition Script", "Script that defines the parameter vector and evaluates the solution for a programmable problem.")]
   [StorableType("D0B2A649-EDDE-4A6E-A3B5-F40F5FD1B2C0")]
-  public sealed class SingleObjectiveProblemDefinitionScript<TEncoding, TSolution> : ProblemDefinitionScript<TEncoding, TSolution>, ISingleObjectiveProblemDefinition<TEncoding, TSolution>, IStorableContent
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public sealed class SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> : ProblemDefinitionScript<TEncoding, TEncodedSolution>, ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>, IStorableContent
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     public string Filename { get; set; }
 
-    private new ISingleObjectiveProblemDefinition<TEncoding, TSolution> CompiledProblemDefinition {
-      get { return (ISingleObjectiveProblemDefinition<TEncoding, TSolution>)base.CompiledProblemDefinition; }
+    private new ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution> CompiledProblemDefinition {
+      get { return (ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>)base.CompiledProblemDefinition; }
     }
 
     [StorableConstructor]
     private SingleObjectiveProblemDefinitionScript(StorableConstructorFlag _) : base(_) { }
-    private SingleObjectiveProblemDefinitionScript(SingleObjectiveProblemDefinitionScript<TEncoding, TSolution> original, Cloner cloner) : base(original, cloner) { }
+    private SingleObjectiveProblemDefinitionScript(SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> original, Cloner cloner) : base(original, cloner) { }
     public SingleObjectiveProblemDefinitionScript(string codeTemplate) : base(codeTemplate) { }
     public SingleObjectiveProblemDefinitionScript() { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveProblemDefinitionScript<TEncoding, TSolution>(this, cloner);
+      return new SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>(this, cloner);
     }
 
-    bool ISingleObjectiveProblemDefinition<TEncoding, TSolution>.Maximization {
+    bool ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Maximization {
       get { return CompiledProblemDefinition.Maximization; }
     }
 
-    double ISingleObjectiveProblemDefinition<TEncoding, TSolution>.Evaluate(TSolution individual, IRandom random) {
+    double ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Evaluate(TEncodedSolution individual, IRandom random) {
       return CompiledProblemDefinition.Evaluate(individual, random);
     }
 
-    void ISingleObjectiveProblemDefinition<TEncoding, TSolution>.Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    void ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>.Analyze(TEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       CompiledProblemDefinition.Analyze(individuals, qualities, results, random);
     }
-    IEnumerable<TSolution> ISingleObjectiveProblemDefinition<TEncoding, TSolution>.GetNeighbors(TSolution individual, IRandom random) {
+    IEnumerable<TEncodedSolution> ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>.GetNeighbors(TEncodedSolution individual, IRandom random) {
       return CompiledProblemDefinition.GetNeighbors(individual, random);
     }
 
-    bool ISingleObjectiveProblemDefinition<TEncoding, TSolution>.IsBetter(double quality, double bestQuality) {
+    bool ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution>.IsBetter(double quality, double bestQuality) {
       return CompiledProblemDefinition.IsBetter(quality, bestQuality);
     }
Index: /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 16750)
+++ /branches/2521_ProblemRefactoring/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 16751)
@@ -36,7 +36,7 @@
   [Creatable(CreatableAttribute.Categories.Problems, Priority = 110)]
   [StorableType("44944E6B-E95E-4805-8F0A-0C0F7D761DB9")]
-  public class SingleObjectiveProgrammableProblem<TEncoding, TSolution> : SingleObjectiveProblem<TEncoding, TSolution>, IProgrammableItem, IProgrammableProblem
-    where TEncoding : class, IEncoding<TSolution>
-    where TSolution : class, ISolution {
+  public class SingleObjectiveProgrammableProblem<TEncoding, TEncodedSolution> : SingleObjectiveProblem<TEncoding, TEncodedSolution>, IProgrammableItem, IProgrammableProblem
+    where TEncoding : class, IEncoding<TEncodedSolution>
+    where TEncodedSolution : class, IEncodedSolution {
     protected static readonly string ENCODING_NAMESPACE = "ENCODING_NAMESPACE";
     protected static readonly string ENCODING_CLASS = "ENCODING_CLASS";
@@ -47,6 +47,6 @@
     }
 
-    private FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TSolution>> SingleObjectiveProblemScriptParameter {
-      get { return (FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TSolution>>)Parameters["ProblemScript"]; }
+    private FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>> SingleObjectiveProblemScriptParameter {
+      get { return (FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>>)Parameters["ProblemScript"]; }
     }
 
@@ -54,13 +54,13 @@
       get { return ProblemScript; }
     }
-    public SingleObjectiveProblemDefinitionScript<TEncoding, TSolution> ProblemScript {
+    public SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution> ProblemScript {
       get { return SingleObjectiveProblemScriptParameter.Value; }
     }
 
-    public ISingleObjectiveProblemDefinition<TEncoding, TSolution> ProblemDefinition {
+    public ISingleObjectiveProblemDefinition<TEncoding, TEncodedSolution> ProblemDefinition {
       get { return SingleObjectiveProblemScriptParameter.Value; }
     }
 
-    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem<TEncoding, TSolution> original, Cloner cloner)
+    protected SingleObjectiveProgrammableProblem(SingleObjectiveProgrammableProblem<TEncoding, TEncodedSolution> original, Cloner cloner)
       : base(original, cloner) {
       RegisterEvents();
@@ -68,5 +68,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SingleObjectiveProgrammableProblem<TEncoding, TSolution>(this, cloner);
+      return new SingleObjectiveProgrammableProblem<TEncoding, TEncodedSolution>(this, cloner);
     }
 
@@ -75,5 +75,5 @@
     public SingleObjectiveProgrammableProblem()
       : base() {
-      Parameters.Add(new FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TSolution>>("ProblemScript", "Defines the problem.", new SingleObjectiveProblemDefinitionScript<TEncoding, TSolution>() { Name = Name }));
+      Parameters.Add(new FixedValueParameter<SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>>("ProblemScript", "Defines the problem.", new SingleObjectiveProblemDefinitionScript<TEncoding, TEncodedSolution>() { Name = Name }));
       ProblemScript.Encoding = (TEncoding)Encoding.Clone();
 
@@ -81,5 +81,5 @@
       codeTemplate = codeTemplate.Replace(ENCODING_NAMESPACE, typeof(TEncoding).Namespace);
       codeTemplate = codeTemplate.Replace(ENCODING_CLASS, typeof(TEncoding).Name);
-      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, typeof(TSolution).Name);
+      codeTemplate = codeTemplate.Replace(SOLUTION_CLASS, typeof(TEncodedSolution).Name);
       ProblemScript.Code = codeTemplate;
 
@@ -118,12 +118,12 @@
     }
 
-    public override double Evaluate(TSolution individual, IRandom random) {
+    public override double Evaluate(TEncodedSolution individual, IRandom random) {
       return ProblemDefinition.Evaluate(individual, random);
     }
 
-    public override void Analyze(TSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+    public override void Analyze(TEncodedSolution[] individuals, double[] qualities, ResultCollection results, IRandom random) {
       ProblemDefinition.Analyze(individuals, qualities, results, random);
     }
-    public override IEnumerable<TSolution> GetNeighbors(TSolution individual, IRandom random) {
+    public override IEnumerable<TEncodedSolution> GetNeighbors(TEncodedSolution individual, IRandom random) {
       return ProblemDefinition.GetNeighbors(individual, random);
     }
