Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9242)
@@ -34,6 +34,10 @@
   public class VariableVectorCoveringCreator : CoveringSolutionCreator, IVariableVectorCoveringCreator {
 
-    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
-      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+
+    private IVariableVectorClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
     }
 
@@ -45,5 +49,5 @@
     public VariableVectorCoveringCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector"));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData"));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -55,18 +59,18 @@
       var actionCast = action as VariableVectorAction;
 
-      VariableVectorCondition sampleVariableVectorCondition = SampleVariableVectorParameter.ActualValue.Condition;
+      VariableVectorCondition sampleVariableVectorCondition = ProblemData.SampleVariableVectorParameter.Value.Condition;
       IEnumerable<IVariable> newCondition = CoverInput(inputCast, sampleVariableVectorCondition, random, changeSymbolProbability);
 
-      return new VariableVector(newCondition, actionCast.Values);
+      return new VariableVector(newCondition, actionCast.VariableDictionary.Values);
     }
 
     private IEnumerable<IVariable> CoverInput(VariableVectorInput input, VariableVectorCondition sample, IRandom random, double changeSymbolProbability) {
-      var conditionVariables = new List<IVariable>();
-      if (!sample.Keys.All(x => input.ContainsKey(x))) {
+      List<IVariable> conditionVariables = new List<IVariable>();
+      if (!sample.VariableDictionary.Keys.All(x => input.InputDictionary.ContainsKey(x))) {
         throw new ArgumentException("Input does not contain all variable names from sample");
       }
-      foreach (var keyValuePair in sample) {
+      foreach (var keyValuePair in sample.VariableDictionary) {
         IVariable variable = keyValuePair.Value.GetEmptyCopy();
-        variable.Cover(random, input[keyValuePair.Key], changeSymbolProbability);
+        variable.Cover(random, input.InputDictionary[keyValuePair.Key], changeSymbolProbability);
         conditionVariables.Add(variable);
       }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9242)
@@ -54,38 +54,38 @@
 
       if (parent1.Count != parent2.Count && parent1.VirtualLength != parent2.VirtualLength
-        && parent1Condition.Count != parent2Condition.Count && parent1Condition.VirtualLength != parent2Condition.VirtualLength
-        && parent1Action.Count != parent2Action.Count && parent1Action.VirtualLength != parent2Action.VirtualLength)
+        && parent1Condition.VariableDictionary.Count != parent2Condition.VariableDictionary.Count && parent1Condition.VirtualLength != parent2Condition.VirtualLength
+        && parent1Action.VariableDictionary.Count != parent2Action.VariableDictionary.Count && parent1Action.VirtualLength != parent2Action.VirtualLength)
         throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
 
       int conditionLength = parent1Condition.VirtualLength;
       int breakPoint = random.Next(1, conditionLength);
-      IList<IVariable> newCondition = new List<IVariable>(parent1Condition.Count);
+      IList<IVariable> newCondition = new List<IVariable>(parent1Condition.VariableDictionary.Count);
 
       var keyEnumerator = parent1Condition.Order.GetEnumerator();
 
       int index = 0;
-      IVariable curVariable;
+      IVariable curVariable = null;
       while (index < breakPoint) {
-        keyEnumerator.MoveNext();
-        curVariable = parent1Condition[keyEnumerator.Current];
-        if (curVariable.VirtualLength == 1 || index + curVariable.VirtualLength - 1 < breakPoint) {
+        if (!keyEnumerator.MoveNext()) { throw new IndexOutOfRangeException("Enumerator has no next element!"); }
+        curVariable = parent1Condition.VariableDictionary[keyEnumerator.Current];
+        if (index + curVariable.VirtualLength <= breakPoint) {
           newCondition.Add(curVariable.GetSetCopy());
-          index += curVariable.VirtualLength;
         }
+        index += curVariable.VirtualLength;
       }
 
       // breakpoint is in between a variable
       if (index != breakPoint) {
-        newCondition.Add(parent1Condition[keyEnumerator.Current].CrossParentsAtPosition(parent2Condition[keyEnumerator.Current], breakPoint - index - 1));
+        newCondition.Add(parent1Condition.VariableDictionary[keyEnumerator.Current].CrossParentsAtPosition(parent2Condition.VariableDictionary[keyEnumerator.Current], breakPoint - (index - curVariable.VirtualLength)));
       }
 
       while (index < conditionLength) {
         keyEnumerator.MoveNext();
-        curVariable = parent2Condition[keyEnumerator.Current];
+        curVariable = parent2Condition.VariableDictionary[keyEnumerator.Current];
         newCondition.Add(curVariable.GetSetCopy());
         index += curVariable.VirtualLength;
       }
 
-      var action = random.Next(2) == 1 ? parent1Action.Values.Select(x => x.GetSetCopy()) : parent2Action.Values.Select(x => x.GetSetCopy());
+      var action = random.Next(2) == 1 ? parent1Action.VariableDictionary.Values.Select(x => x.GetSetCopy()) : parent2Action.VariableDictionary.Values.Select(x => x.GetSetCopy());
 
       return new VariableVector(newCondition, action);
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9242)
@@ -85,4 +85,6 @@
     <Compile Include="Covering\VariableVectorCoveringCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorClassificationProblem.cs" />
+    <Compile Include="Interfaces\IVariableVectorClassificationProblemData.cs" />
     <Compile Include="Interfaces\IVariableVectorCoveringCreator.cs" />
     <Compile Include="Interfaces\IVariableVectorCrossover.cs" />
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblem.cs	(revision 9242)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblem.cs	(revision 9242)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorClassificationProblem : IConditionActionProblem {
+    new IFixedValueParameter<VariableVectorActionComparer> ClassifierComparerParameter { get; }
+    IVariableVectorCoveringCreator VariableVectorCoveringCreator { get; }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblemData.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblemData.cs	(revision 9242)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblemData.cs	(revision 9242)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorClassificationProblemData : IConditionActionProblemData {
+    IFixedValueParameter<VariableVector> SampleVariableVectorParameter { get; }
+    IFixedValueParameter<PercentValue> SpreadPercentageParameter { get; }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs	(revision 9242)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.VariableVector {
   public interface IVariableVectorCoveringCreator : ICoveringSolutionCreator, IVariableVectorOperator {
-    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+    IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter { get; }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs	(revision 9242)
@@ -21,13 +21,10 @@
 
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.VariableVector {
   public interface IVariableVectorCreator : ISolutionCreator, IVariableVectorOperator {
-    IValueLookupParameter<PercentValue> SpreadPercentageParameter { get; }
-    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+    IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter { get; }
     ILookupParameter<VariableVector> VariableVectorParameter { get; }
-
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9242)
@@ -60,5 +60,5 @@
       int actionIndex = random.Next(otherActions.Count());
       VariableVectorAction newAction = otherActions.ElementAt(actionIndex);
-      return new VariableVector(child.Condition.Values.Select(x => x.GetSetCopy()), newAction.Values.Select(x => x.GetSetCopy()));
+      return new VariableVector(child.Condition.VariableDictionary.Values.Select(x => x.GetSetCopy()), newAction.VariableDictionary.Values.Select(x => x.GetSetCopy()));
     }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9242)
@@ -57,9 +57,9 @@
       int count = 0;
       keyEnumerator.MoveNext();
-      while (count < condition.VirtualLength && count < index && count + condition[keyEnumerator.Current].VirtualLength <= index) {
-        count += condition[keyEnumerator.Current].VirtualLength;
+      while (count < condition.VirtualLength && count < index && count + condition.VariableDictionary[keyEnumerator.Current].VirtualLength <= index) {
+        count += condition.VariableDictionary[keyEnumerator.Current].VirtualLength;
         keyEnumerator.MoveNext();
       }
-      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current], index - count);
+      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count);
       return child;
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9242)
@@ -66,4 +66,6 @@
       min = original.min;
       max = original.max;
+      currentSpread = original.currentSpread;
+      currentCenter = original.currentCenter;
     }
     public DoubleVariable() : base() { }
@@ -89,5 +91,5 @@
 
     public override string ToString() {
-      return (currentCenter - currentCenter) + " - " + (currentCenter + currentSpread);
+      return (currentCenter - currentSpread) + " - " + (currentCenter + currentSpread);
     }
 
@@ -97,5 +99,5 @@
 
     public override bool Match(double target) {
-      return currentCenter - currentSpread < target && target < currentCenter + currentSpread;
+      return currentCenter - currentSpread <= target && target <= currentCenter + currentSpread;
     }
 
@@ -128,7 +130,7 @@
       var targetCast = target as DoubleVariable;
       if (targetCast == null) { return false; }
-      if (variableName != targetCast.variableName || currentCenter != targetCast.currentCenter
-        || currentSpread != targetCast.currentSpread || max != targetCast.max
-        || min != targetCast.min) { return false; }
+      if (variableName != targetCast.variableName || currentCenter.IsAlmost(targetCast.currentCenter)
+        || currentSpread.IsAlmost(targetCast.currentSpread) || max.IsAlmost(targetCast.max)
+        || min.IsAlmost(targetCast.min)) { return false; }
 
       return true;
@@ -149,10 +151,10 @@
     }
 
-    public new DoubleVariable CrossParentsAtPosition(IVariable parent2, int pos) {
-      var parent2Cast = parent2 as DoubleVariable;
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+      DoubleVariable parent2Cast = parent2 as DoubleVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
       DoubleVariable crossed = (DoubleVariable)this.GetSetCopy();
-      if (pos == 0) {
+      if (pos == 1) {
         crossed.CurrentSpread = parent2Cast.CurrentSpread;
       }
@@ -180,5 +182,5 @@
 
     public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
-      Cover(random, stringValue, 50);
+      CoverWithSpreadPercentage(random, stringValue, changeSymbolProbability);
     }
 
@@ -186,5 +188,5 @@
       currentCenter = double.Parse(stringValue);
       double delta = max - min;
-      currentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+      currentSpread = random.NextDouble() * (delta * spreadPercentage);
     }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9242)
@@ -30,4 +30,5 @@
 
     IVariable GetEmptyCopy();
+    //GetSetCopy is used instead of Clone, so that data doesn't have to be duplicated
     IVariable GetSetCopy();
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9242)
@@ -149,9 +149,9 @@
     }
 
-    public new IntVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
       var parent2Cast = parent2 as IntVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return (IntVariable)this.GetSetCopy();
+      return (IntVariable)parent2.GetSetCopy();
     }
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9242)
@@ -198,9 +198,9 @@
     }
 
-    public new StringVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
       var parent2Cast = parent2 as StringVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return (StringVariable)this.GetSetCopy();
+      return (StringVariable)parent2.GetSetCopy();
     }
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9242)
@@ -68,5 +68,5 @@
     public abstract bool IsGreaterThanOrEquallyGeneral(IVariable target);
 
-    public virtual IVariable CrossParentsAtPosition(IVariable parent2, int pos) { throw new NotSupportedException("This method is not supported."); }
+    public abstract IVariable CrossParentsAtPosition(IVariable parent2, int pos);
 
     public abstract void Manipulate(IRandom random, string stringValue, int pos);
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9242)
@@ -43,9 +43,9 @@
 
     public int Count {
-      get { return condition.Count + action.Count; }
+      get { return condition.VariableDictionary.Count + action.VariableDictionary.Count; }
     }
 
     public int VirtualLength {
-      get { return condition.Values.Sum(x => x.VirtualLength) + action.Values.Sum(x => x.VirtualLength); }
+      get { return condition.VariableDictionary.Values.Sum(x => x.VirtualLength) + action.VariableDictionary.Values.Sum(x => x.VirtualLength); }
     }
 
@@ -73,5 +73,5 @@
 
     public VariableVector GetEmptyCopy() {
-      return new VariableVector(Condition.Values.Select(x => x.GetEmptyCopy()), Action.Values.Select(x => x.GetEmptyCopy()));
+      return new VariableVector(Condition.VariableDictionary.Values.Select(x => x.GetEmptyCopy()), Action.VariableDictionary.Values.Select(x => x.GetEmptyCopy()));
     }
 
@@ -112,15 +112,15 @@
 
     public bool IsMoreGeneral(ICondition target) {
-      var targetCast = target as VariableVector;
+      var targetCast = target as VariableVectorCondition;
       if (targetCast == null) { return false; }
-      if (Condition.Keys.Except(targetCast.Condition.Keys).Count() != 0
-        || targetCast.Condition.Keys.Except(Condition.Keys).Count() != 0) { return false; }
+      if (Condition.VariableDictionary.Keys.Except(targetCast.VariableDictionary.Keys).Count() != 0
+        || targetCast.VariableDictionary.Keys.Except(Condition.VariableDictionary.Keys).Count() != 0) { return false; }
 
-      double thisGenerality = Condition.Values.Sum(x => x.GetGenerality());
-      double targetGenerality = Condition.Values.Sum(x => x.GetGenerality());
+      double thisGenerality = Condition.VariableDictionary.Values.Sum(x => x.GetGenerality());
+      double targetGenerality = targetCast.VariableDictionary.Values.Sum(x => x.GetGenerality());
       if (thisGenerality <= targetGenerality) { return false; }
 
-      foreach (var variables in targetCast.Condition) {
-        if (!Condition[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
+      foreach (var variables in targetCast.VariableDictionary) {
+        if (!Condition.VariableDictionary[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
           return false;
         }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9242)
@@ -20,7 +20,5 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33,42 +31,50 @@
   [StorableClass]
   [Item("VariableVectorAction", "")]
-  public class VariableVectorAction : Dictionary<string, IActionVariable>, IAction {
+  public class VariableVectorAction : Item, IAction {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, IActionVariable> variableDictionary;
+    public Dictionary<string, IActionVariable> VariableDictionary {
+      get { return variableDictionary; }
+      protected set { variableDictionary = value; }
+    }
 
-    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+    public IOrderedEnumerable<string> Order { get { return VariableDictionary.Keys.OrderBy(x => x); } }
+
+    public int VirtualLength { get { return VariableDictionary.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
     protected VariableVectorAction(bool deserializing) { }
     protected VariableVectorAction(VariableVectorAction original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (IActionVariable)item.Value.Clone());
+      VariableDictionary = new Dictionary<string, IActionVariable>(original.VariableDictionary.Count);
+      foreach (var item in original.VariableDictionary) {
+        VariableDictionary.Add(item.Key, cloner.Clone(item.Value));
       }
     }
-    public VariableVectorAction() : base() { }
-    public VariableVectorAction(int capacity) : base(capacity) { }
-    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary) : base(dictionary) { }
-
-    //protected override void OnItemsAdded(IEnumerable<KeyValuePair<string, IActionVariable>> items) {
-    //  foreach (var item in items) {
-    //    if (!(item.Value is StringVariable || item.Value is IntVariable)) {
-    //      throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
-    //    }
-    //  }
-    //}
+    public VariableVectorAction()
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>();
+    }
+    public VariableVectorAction(int capacity)
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>(capacity);
+    }
+    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary)
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorAction(this, cloner);
+    }
 
     public VariableVectorAction GetEmptyCopy() {
-      VariableVectorAction emptyCopy = new VariableVectorAction(this.Count);
-      foreach (var keyValuePair in this) {
-        emptyCopy.Add(keyValuePair.Key, keyValuePair.Value.GetEmptyCopy());
-      }
+      VariableVectorAction emptyCopy = new VariableVectorAction(VariableDictionary.Count);
+      emptyCopy.Add(VariableDictionary.Values.Select(x => x.GetEmptyCopy()));
       return emptyCopy;
     }
 
     public VariableVectorAction GetSetCopy() {
-      VariableVectorAction setCopy = new VariableVectorAction(this.Count);
-      foreach (var keyValuePair in this) {
-        setCopy.Add(keyValuePair.Key, keyValuePair.Value.GetSetCopy());
-      }
+      VariableVectorAction setCopy = new VariableVectorAction(VariableDictionary.Count);
+      setCopy.Add(VariableDictionary.Values.Select(x => x.GetSetCopy()));
       return setCopy;
     }
@@ -78,6 +84,6 @@
       if (targetCast == null) { return false; }
       if (!this.Order.SequenceEqual(targetCast.Order)) { return false; }
-      foreach (var keyValuePair in targetCast) {
-        if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
+      foreach (var keyValuePair in targetCast.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
           return false;
         }
@@ -88,5 +94,5 @@
     public void Add(IEnumerable<IActionVariable> action) {
       foreach (var variable in action) {
-        this.Add(variable.VariableName, variable);
+        VariableDictionary.Add(variable.VariableName, variable);
       }
     }
@@ -95,5 +101,5 @@
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (first) {
           first = false;
@@ -107,5 +113,5 @@
 
     public void Randomize(IRandom random) {
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         variable.Randomize(random);
       }
@@ -113,7 +119,7 @@
 
     public bool Identical(VariableVectorAction target) {
-      if (this.Order.SequenceEqual(target.Order)) { return false; }
-      foreach (var keyValuePair in target) {
-        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+      if (!this.Order.SequenceEqual(target.Order)) { return false; }
+      foreach (var keyValuePair in target.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].Identical(keyValuePair.Value)) {
           return false;
         }
@@ -121,39 +127,4 @@
       return true;
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorAction(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs	(revision 9242)
@@ -44,6 +44,6 @@
     public bool Equals(VariableVectorAction x, VariableVectorAction y) {
       if (!x.Order.SequenceEqual(y.Order)) return false;
-      foreach (var key in x.Keys) {
-        if (!x[key].Identical(y[key])) {
+      foreach (var key in x.VariableDictionary.Keys) {
+        if (!x.VariableDictionary[key].Identical(y.VariableDictionary[key])) {
           return false;
         }
@@ -54,9 +54,9 @@
     public int GetHashCode(VariableVectorAction obj) {
       int result = 1;
-      foreach (var key in obj.Keys) {
+      foreach (var key in obj.VariableDictionary.Keys) {
         result = 37 * result + key.GetHashCode();
       }
 
-      foreach (var val in obj.Values) {
+      foreach (var val in obj.VariableDictionary.Values) {
         result = 37 * result + val.GetHashCode();
       }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9242)
@@ -20,7 +20,5 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33,27 +31,46 @@
   [StorableClass]
   [Item("VariableVectorCondition", "")]
-  public class VariableVectorCondition : Dictionary<string, IVariable>, ICondition {
+  public class VariableVectorCondition : Item, ICondition {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, IVariable> variableDictionary;
+    public Dictionary<string, IVariable> VariableDictionary {
+      get { return variableDictionary; }
+      protected set { variableDictionary = value; }
+    }
 
-    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+    public IOrderedEnumerable<string> Order { get { return VariableDictionary.Keys.OrderBy(x => x); } }
+
+    public int VirtualLength { get { return VariableDictionary.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
     protected VariableVectorCondition(bool deserializing) { }
     protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (IVariable)item.Value.Clone());
+      VariableDictionary = new Dictionary<string, IVariable>(original.VariableDictionary.Count);
+      foreach (var item in original.VariableDictionary) {
+        VariableDictionary.Add(item.Key, cloner.Clone(item.Value));
       }
     }
-    public VariableVectorCondition() : base() { }
-    public VariableVectorCondition(int capacity) : base(capacity) { }
-    public VariableVectorCondition(IDictionary<string, IVariable> dictionary) : base(dictionary) { }
+    public VariableVectorCondition()
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>();
+    }
+    public VariableVectorCondition(int capacity)
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>(capacity);
+    }
+    public VariableVectorCondition(IDictionary<string, IVariable> dictionary)
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorCondition(this, cloner);
+    }
 
     public bool Match(IInput target) {
       var targetCast = target as VariableVectorInput;
       if (targetCast == null) { return false; }
-      if (!this.Keys.All(x => targetCast.Keys.Contains(x))) { return false; }
-      foreach (var key in this.Keys) {
-        if (!this[key].MatchInput(targetCast[key])) {
+      foreach (var key in VariableDictionary.Keys) {
+        if (!targetCast.InputDictionary.ContainsKey(key) || !VariableDictionary[key].MatchInput(targetCast.InputDictionary[key])) {
           return false;
         }
@@ -64,5 +81,5 @@
     public void Add(IEnumerable<IVariable> condition) {
       foreach (var variable in condition) {
-        this.Add(variable.VariableName, variable);
+        VariableDictionary.Add(variable.VariableName, variable);
       }
     }
@@ -71,5 +88,5 @@
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (first) {
           first = false;
@@ -83,5 +100,5 @@
 
     public void Randomize(IRandom random, double spreadPercentage) {
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (variable is DoubleVariable) {
           ((DoubleVariable)variable).Randomize(random, spreadPercentage);
@@ -94,6 +111,6 @@
     public bool Identical(VariableVectorCondition target) {
       if (!this.Order.SequenceEqual(target.Order)) { return false; }
-      foreach (var keyValuePair in target) {
-        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+      foreach (var keyValuePair in target.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].Identical(keyValuePair.Value)) {
           return false;
         }
@@ -101,39 +118,4 @@
       return true;
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorCondition(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs	(revision 9242)
@@ -22,5 +22,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -34,9 +33,6 @@
 
     #region Parameter Properties
-    public IValueLookupParameter<PercentValue> SpreadPercentageParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["SpreadPercentage"]; }
-    }
-    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
-      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
     }
     public ILookupParameter<VariableVector> VariableVectorParameter {
@@ -48,4 +44,8 @@
     #endregion
 
+    protected IVariableVectorClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
+    }
+
     [StorableConstructor]
     protected VariableVectorCreator(bool deserializing) : base(deserializing) { }
@@ -55,6 +55,5 @@
     public VariableVectorCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<PercentValue>("SpreadPercentage", ""));
-      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector", ""));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData", ""));
       Parameters.Add(new LookupParameter<VariableVector>("VariableVector", ""));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
@@ -62,5 +61,5 @@
 
     public override IOperation Apply() {
-      VariableVectorParameter.ActualValue = Create(RandomParameter.ActualValue, SampleVariableVectorParameter.ActualValue, SpreadPercentageParameter.ActualValue.Value);
+      VariableVectorParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemData.SampleVariableVectorParameter.Value, ProblemData.SpreadPercentageParameter.Value.Value);
       return base.Apply();
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9228)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9242)
@@ -22,5 +22,4 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33,23 +32,45 @@
   [StorableClass]
   [Item("VariableVectorInput", "")]
-  public class VariableVectorInput : Dictionary<string, string>, IInput {
+  public class VariableVectorInput : Item, IInput {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, string> inputDictionary;
+    public Dictionary<string, string> InputDictionary {
+      get { return inputDictionary; }
+      protected set {
+        inputDictionary = value;
+      }
+    }
+
+    public IOrderedEnumerable<string> Order { get { return InputDictionary.Keys.OrderBy(x => x); } }
 
     [StorableConstructor]
     protected VariableVectorInput(bool deserializing) { }
     protected VariableVectorInput(VariableVectorInput original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (string)item.Value.Clone());
+      InputDictionary = new Dictionary<string, string>(original.InputDictionary.Count);
+      foreach (var item in original.InputDictionary) {
+        InputDictionary.Add(item.Key, item.Value);
       }
     }
-    public VariableVectorInput() : base() { }
-    public VariableVectorInput(int capacity) : base(capacity) { }
-    public VariableVectorInput(IDictionary<string, string> dictionary) : base(dictionary) { }
+    public VariableVectorInput()
+      : base() {
+      InputDictionary = new Dictionary<string, string>();
+    }
+    public VariableVectorInput(int capacity)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(capacity);
+    }
+    public VariableVectorInput(IDictionary<string, string> dictionary)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorInput(this, cloner);
+    }
 
     public override string ToString() {
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var item in this) {
+      foreach (var item in InputDictionary) {
         if (first) {
           first = false;
@@ -61,39 +82,4 @@
       return sb.ToString();
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorInput(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }
