Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj	(revision 9194)
@@ -50,8 +50,4 @@
     <Reference Include="HeuristicLab.Common-3.3">
       <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3">
-      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -116,4 +112,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9194)
@@ -76,4 +76,5 @@
     private DoDeletionBeforeCoveringOperator doDeletionBeforeCovering;
     private CoveringOperator covering;
+    private CountNumberOfUniqueActions countNumberOfUniqueActions;
 
     private UniformSomePositionManipulator test;
@@ -136,5 +137,5 @@
       ConditionalSelector actionMatchSelector = new ConditionalSelector();
       SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
-      CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
+      countNumberOfUniqueActions = new CountNumberOfUniqueActions();
       doDeletionBeforeCovering = new DoDeletionBeforeCoveringOperator();
       ConditionalBranch doDeletionBeforeCoveringConditionalBranch = new ConditionalBranch();
@@ -439,5 +440,5 @@
       classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
 
-      test.FetchedClassifierParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      test.FetchedConditionParameter.ActualName = problem.ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
       test.PossibleActionsParameter.ActualName = problem.PossibleActionsConcreteClassParameter.Name;
 
@@ -454,7 +455,8 @@
       actionSetSubsumption.OperatorParameter.ActualName = problem.ActionSetSubsumptionOperatorParameter.Name;
 
-      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
 
       doDeletionBeforeCovering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
+      doDeletionBeforeCovering.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
 
       covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
@@ -465,4 +467,7 @@
       predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
       predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
+      predictionArrayCalculator.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
+
+      countNumberOfUniqueActions.ClassifierComparerParameter.ActualName = problem.ClassifierComparerParameter.Name;
     }
     //private void ParameterizeSelectors() {
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Collections/ItemDictionary.cs	(revision 9194)
@@ -59,5 +59,7 @@
     public ItemDictionary() : base() { }
     public ItemDictionary(int capacity) : base(capacity) { }
+    public ItemDictionary(IEqualityComparer<TKey> comparer) : base(comparer) { }
     public ItemDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
+    public ItemDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : base(dictionary, comparer) { }
 
     public object Clone() {
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/HeuristicLab.Core-3.3.csproj	(revision 9194)
@@ -41,5 +41,5 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -52,5 +52,5 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -63,5 +63,5 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -71,5 +71,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <DocumentationFile>
@@ -83,5 +83,5 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <DebugType>full</DebugType>
@@ -91,5 +91,5 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <DocumentationFile>
@@ -102,4 +102,19 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
@@ -205,31 +220,4 @@
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
-      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
-      <Name>HeuristicLab.Collections-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
-      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
-      <Name>HeuristicLab.Common.Resources-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
-      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
-      <Name>HeuristicLab.Common-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
-      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
-      <Name>HeuristicLab.Persistence-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
-      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
-      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
     <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
       <Visible>False</Visible>
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9194)
@@ -21,4 +21,5 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -33,5 +34,5 @@
   [StorableClass]
   [Item("CombinedIntegerVector", "Represents a combined vector of integer values.")]
-  public class CombinedIntegerVector : IntegerVector, IClassifier {
+  public class CombinedIntegerVector : IntegerVector, IClassifier, ICondition, IAction, IInput {
 
     [Storable]
@@ -121,5 +122,5 @@
     }
 
-    public IClassifier Condition {
+    public ICondition Condition {
       get {
         int[] condition = new int[Length - actionLength];
@@ -129,5 +130,5 @@
     }
 
-    public IClassifier Action {
+    public IAction Action {
       get {
         int[] action = new int[actionLength];
@@ -152,8 +153,8 @@
     }
 
-    public bool MatchCondition(IClassifier target) {
+    public bool MatchInput(IInput target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
-      if (targetVector.Length != this.Length) return false;
+      if (targetVector.Length - targetVector.actionLength != this.Length - this.actionLength) return false;
 
       int curbounds;
@@ -171,6 +172,10 @@
     }
 
+    public bool MatchAction(IClassifier target) {
+      return MatchAction(target.Action);
+    }
+
     // no "don't care" symbols have to be considered
-    public bool MatchAction(IClassifier target) {
+    public bool MatchAction(IAction target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
@@ -188,4 +193,8 @@
 
     public bool IsMoreGeneral(IClassifier target) {
+      return IsMoreGeneral(target as ICondition);
+    }
+
+    public bool IsMoreGeneral(ICondition target) {
       var targetVector = target as CombinedIntegerVector;
       int curbounds;
@@ -201,4 +210,16 @@
       return true;
     }
+
+    #region ICondition Members
+    public bool Match(IInput target) {
+      return MatchInput(target);
+    }
+    #endregion
+
+    #region IAction Members
+    public bool Match(IAction target) {
+      return MatchAction(target);
+    }
+    #endregion
 
     private int NumberOfGeneralSymbols() {
@@ -233,14 +254,6 @@
     }
 
-    public override bool Equals(object obj) {
-      var cast = obj as CombinedIntegerVector;
-      if (cast != null) {
-        return this.Equals(cast);
-      }
-      return false;
-    }
-
-    public bool Equals(IClassifier other) {
-      var cast = other as CombinedIntegerVector;
+    public bool Identical(IClassifier target) {
+      var cast = target as CombinedIntegerVector;
       if (cast == null) { return false; }
       for (int i = 0; i < array.Length; i++) {
@@ -252,10 +265,53 @@
     }
 
+    public override bool Equals(object obj) {
+      return base.Equals(obj);
+    }
+
     public override int GetHashCode() {
-      int result = actionLength;
-      for (int i = 0; i < array.Length; i++) {
-        result ^= array[i];
-      }
-      return result.GetHashCode();
+      return base.GetHashCode();
+    }
+
+    [StorableClass]
+    [Item("CombinedIntegerVectorComparer", "")]
+    public class CombinedIntegerVectorComparer : Item, IEqualityComparer<CombinedIntegerVector>, IClassifierComparer {
+
+      [StorableConstructor]
+      protected CombinedIntegerVectorComparer(bool deserializing) : base(deserializing) { }
+      protected CombinedIntegerVectorComparer(CombinedIntegerVectorComparer original, Cloner cloner)
+        : base(original, cloner) {
+      }
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new CombinedIntegerVectorComparer(this, cloner);
+      }
+      public CombinedIntegerVectorComparer() : base() { }
+
+      public bool Equals(CombinedIntegerVector x, CombinedIntegerVector y) {
+        for (int i = 0; i < x.array.Length; i++) {
+          if (!x.array[i].Equals(y.array[i])) {
+            return false;
+          }
+        }
+        return true;
+      }
+
+      public int GetHashCode(CombinedIntegerVector obj) {
+        int result = obj.actionLength;
+        for (int i = 0; i < obj.array.Length; i++) {
+          result ^= obj.array[i];
+        }
+        return result.GetHashCode();
+      }
+
+      public bool Equals(IAction x, IAction y) {
+        var xCast = x as CombinedIntegerVector;
+        var yCast = y as CombinedIntegerVector;
+        return x != null && y != null && Equals(xCast, yCast);
+      }
+
+      public int GetHashCode(IAction obj) {
+        var objCast = obj as CombinedIntegerVector;
+        return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
+      }
     }
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9194)
@@ -39,5 +39,5 @@
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
     }
-    public ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter {
+    public ILookupParameter<CombinedIntegerVector> FetchedConditionParameter {
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
     }
@@ -57,5 +57,5 @@
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedClassifierParameter.ActualValue, ChildParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedConditionParameter.ActualValue, ChildParameter.ActualValue);
       return base.Apply();
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9194)
@@ -34,9 +34,9 @@
 
     #region Parameter Properties
-    public ILookupParameter<IClassifier> CoverClassifierParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
+    public ILookupParameter<IInput> CoverInputParameter {
+      get { return (ILookupParameter<IInput>)Parameters["CoverInput"]; }
     }
-    public ILookupParameter<IClassifier> ActionParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["Action"]; }
+    public ILookupParameter<IAction> ActionParameter {
+      get { return (ILookupParameter<IAction>)Parameters["Action"]; }
     }
     public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
@@ -62,6 +62,6 @@
     public CombinedIntegerVectorCoveringCreator()
       : base() {
-      Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
-      Parameters.Add(new LookupParameter<IClassifier>("Action"));
+      Parameters.Add(new LookupParameter<IInput>("CoverInput"));
+      Parameters.Add(new LookupParameter<IAction>("Action"));
       Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
       Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
@@ -70,8 +70,8 @@
 
     public override IOperation Apply() {
-      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition.Clone();
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverInputParameter.ActualValue.Clone();
 
-      CombinedIntegerVector condition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition;
-      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
+      CombinedIntegerVector condition = (CombinedIntegerVector)CoverInputParameter.ActualValue;
+      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue;
 
       newCondition = UniformSomePositionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9194)
@@ -89,7 +89,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <Private>False</Private>
@@ -149,4 +146,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
       <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9194)
@@ -29,5 +29,5 @@
   public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
     ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
-    ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter { get; }
+    ILookupParameter<CombinedIntegerVector> FetchedConditionParameter { get; }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs	(revision 9194)
@@ -37,9 +37,9 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IClassifier> SelectedActionParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    public IValueLookupParameter<IAction> SelectedActionParameter {
+      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
     }
-    public ILookupParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
-      get { return (ILookupParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
+    public ILookupParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
+      get { return (ILookupParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
     }
     public ILookupParameter<PercentValue> ExplorationProbabilityParameter {
@@ -55,6 +55,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random"));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
-      Parameters.Add(new LookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
+      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
+      Parameters.Add(new LookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
       Parameters.Add(new LookupParameter<PercentValue>("ExplorationProbability"));
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs	(revision 9194)
@@ -36,4 +36,7 @@
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ValueParameter"]; }
     }
+    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
+      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
+    }
 
     [StorableConstructor]
@@ -43,4 +46,5 @@
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ValueParameter", "DoubleValue which will be summed up."));
+      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -48,6 +52,6 @@
     }
 
-    protected override IClassifier SelectAction(List<IScope> scopes) {
-      Dictionary<IClassifier, double> actionSet = new Dictionary<IClassifier, double>();
+    protected override IAction SelectAction(List<IScope> scopes) {
+      Dictionary<IAction, double> actionSet = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
       for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
         var action = MatchParameter.ActualValue[i].Action;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs	(revision 9194)
@@ -38,6 +38,6 @@
       get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
     }
-    public IValueLookupParameter<IClassifier> SelectedActionParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    public IValueLookupParameter<IAction> SelectedActionParameter {
+      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
     }
 
@@ -54,5 +54,5 @@
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
+      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
     }
 
@@ -63,5 +63,5 @@
     }
 
-    protected abstract IClassifier SelectAction(List<IScope> scopes);
+    protected abstract IAction SelectAction(List<IScope> scopes);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs	(revision 9194)
@@ -45,5 +45,5 @@
     }
 
-    protected override IClassifier SelectAction(List<IScope> scopes) {
+    protected override IAction SelectAction(List<IScope> scopes) {
       IRandom random = RandomParameter.ActualValue;
       int index = random.Next(MatchParameter.ActualValue.Length);
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Analyzer/XCSSolutionAnalyzer.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Analyzer/XCSSolutionAnalyzer.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Analyzer/XCSSolutionAnalyzer.cs	(revision 9194)
@@ -66,4 +66,7 @@
       get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
     }
+    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
+      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
+    }
 
     public ResultCollection Results { get { return ResultsParameter.ActualValue; } }
@@ -84,4 +87,5 @@
       Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData", ""));
       Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the solution should be stored."));
+      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
     }
 
@@ -105,5 +109,5 @@
 
       XCSModel xcsModel = new XCSModel(xcsClassifiers);
-
+      xcsModel.ClassifierComparer = ClassifierComparerParameter.ActualValue;
       UseCurrentXCSSolution(xcsModel.CreateConditionActionSolution(problemData));
       return base.Apply();
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9194)
@@ -35,9 +35,9 @@
 
     #region Parameter Properties
-    public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
-      get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
+    public ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter {
+      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["ActionsInMatchSet"]; }
     }
-    public ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter {
-      get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    public ILookupParameter<IItemSet<IAction>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["PossibleActions"]; }
     }
     public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
@@ -77,7 +77,6 @@
     public CoveringOperator()
       : base() {
-      Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
-      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("ActionsInMatchSet"));
-      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("PossibleActions"));
+      Parameters.Add(new LookupParameter<IItemSet<IAction>>("ActionsInMatchSet"));
+      Parameters.Add(new LookupParameter<IItemSet<IAction>>("PossibleActions"));
       Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
@@ -95,5 +94,5 @@
       bool parallel = ParallelParameter.ActualValue.Value;
 
-      IItemSet<IClassifier> clone = (IItemSet<IClassifier>)PossibleActionsParameter.ActualValue.Clone();
+      IItemSet<IAction> clone = (IItemSet<IAction>)PossibleActionsParameter.ActualValue.Clone();
       clone.ExceptWith(ActionsInMatchSetParameter.ActualValue);
 
@@ -116,7 +115,7 @@
           VariableCreator variableCreator = new VariableCreator();
           int pos = RandomParameter.ActualValue.Next(clone.Count);
-          IClassifier action = clone.ElementAt(pos);
+          IAction action = clone.ElementAt(pos);
           clone.Remove(action);
-          variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
+          variableCreator.CollectedValues.Add(new ValueParameter<IAction>("Action", action));
           variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
           creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9194)
@@ -55,4 +55,7 @@
       get { return (IValueLookupParameter<IntValue>)Parameters["NumberToDelete"]; }
     }
+    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
+      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
+    }
     #endregion
 
@@ -71,4 +74,5 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("DoDeletion"));
       Parameters.Add(new ValueLookupParameter<IntValue>("NumberToDelete"));
+      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -77,5 +81,5 @@
 
     public override IOperation Apply() {
-      IItemSet<IClassifier> uniqueActions = new ItemSet<IClassifier>();
+      IItemSet<IAction> uniqueActions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
       var classifiers = ClassifiersParameter.ActualValue;
       var matchcondition = MatchConditionParameter.ActualValue;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9194)
@@ -26,6 +26,6 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface ICovering : IStochasticOperator {
-    ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
-    ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }
+    ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter { get; }
+    ILookupParameter<IItemSet<IAction>> PossibleActionsParameter { get; }
 
     ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9194)
@@ -28,6 +28,6 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable, IStochasticOperator {
-    ILookupParameter<IClassifier> CoverClassifierParameter { get; }
-    ILookupParameter<IClassifier> ActionParameter { get; }
+    ILookupParameter<IInput> CoverInputParameter { get; }
+    ILookupParameter<IAction> ActionParameter { get; }
 
     IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs	(revision 9194)
@@ -86,5 +86,5 @@
         IClassifier cl = classifiers[indices];
         for (int i = 0; i < classifiers.Length; i++) {
-          if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Equals(classifiers[i])) {
+          if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Identical(classifiers[i])) {
             numerosities[i].Value += numerosities[indices].Value;
             hasToBeDeleted[indices].Value = true;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9194)
@@ -43,7 +43,4 @@
     </Reference>
     <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <Private>False</Private>
     </Reference>
@@ -124,6 +121,4 @@
     <Compile Include="Reinforcement\IActionExecuter.cs" />
     <Compile Include="Reinforcement\IClassifierFetcher.cs" />
-    <Compile Include="Selectors\IMatchSelector.cs" />
-    <Compile Include="Selectors\MatchSelector.cs" />
     <Compile Include="Selectors\PreservingRightReducer.cs" />
     <Compile Include="Subsumption\ActionSetSubsumptionOperator.cs" />
@@ -140,5 +135,10 @@
     <None Include="Plugin.cs.frame" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9194)
@@ -20,25 +20,30 @@
 #endregion
 
-using System;
+using System.Collections.Generic;
 using HeuristicLab.Core;
 
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
-  /// <summary>
-  /// IMatching is used in dictinoaries, therefore the methods "Equals" and "GetHashCode" have to be overriden
-  /// IEquatable<IMatching> should be implemented as well.
-  /// 
-  /// This also helps to implement macroclassifiers later on
-  /// </summary>
-  public interface IClassifier : IItem, IEquatable<IClassifier> {
-    IClassifier Condition { get; }
-    IClassifier Action { get; }
-    bool MatchCondition(IClassifier target);
-    bool MatchAction(IClassifier target);
+  public interface IClassifier : IItem {
+    ICondition Condition { get; }
+    IAction Action { get; }
+
+    bool MatchInput(IInput target);
+    bool MatchAction(IAction target);
     bool IsMoreGeneral(IClassifier target);
+    bool IsMoreGeneral(ICondition target);
 
-    //to use IMatching as key in a dictionary, Equals and GetHashCode have to be override. 
-    //Also IEquatable<Class> should be implemented.
-    bool Equals(object obj);
-    int GetHashCode();
+    bool Identical(IClassifier target);
   }
+
+  public interface ICondition : IItem {
+    bool Match(IInput target);
+  }
+
+  public interface IAction : IItem {
+    bool Match(IAction target);
+  }
+
+  public interface IInput : IItem { }
+
+  public interface IClassifierComparer : IEqualityComparer<IAction>, IItem { }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionModel.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionModel.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionModel.cs	(revision 9194)
@@ -28,6 +28,6 @@
 
     int ClassifierCount { get; }
-    IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers);
-    IClassifier GetAction(IClassifier classifier);
+    IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers);
+    IAction GetAction(IInput classifier);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9194)
@@ -37,4 +37,6 @@
     //IItemSet<IClassifier> PossibleActions { get; }
 
+    IParameter ClassifierComparerParameter { get; }
+
     ICoveringSolutionCreator CoveringSolutionCreator { get; }
     IParameter CoveringSolutionCreatorParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs	(revision 9194)
@@ -43,6 +43,9 @@
     bool IsTestSample(int index);
 
-    IEnumerable<IClassifier> FetchClassifier(IEnumerable<int> rows);
-    IClassifier FetchClassifier(int rowNumber);
+    IEnumerable<IInput> FetchInput(IEnumerable<int> rows);
+    IInput FetchInput(int rowNumber);
+
+    IEnumerable<IAction> FetchAction(IEnumerable<int> rows);
+    IAction FetchAction(int rowNumber);
 
     event EventHandler Changed;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9194)
@@ -35,6 +35,9 @@
       get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
     }
-    public IValueLookupParameter<IItemSet<IClassifier>> UniqueActionsParameter {
-      get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
+    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
+      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
+    }
+    public IValueLookupParameter<IItemSet<IAction>> UniqueActionsParameter {
+      get { return (IValueLookupParameter<IItemSet<IAction>>)Parameters["UniqueActions"]; }
     }
     public IValueLookupParameter<IntValue> NumberOfUniqueActionsParameter {
@@ -53,10 +56,11 @@
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
-      Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
+      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
+      Parameters.Add(new ValueLookupParameter<IItemSet<IAction>>("UniqueActions"));
       Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfUniqueActions"));
     }
 
     public override IOperation Apply() {
-      ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
+      ItemSet<IAction> actions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
       foreach (var classifier in ClassifiersParameter.ActualValue) {
         actions.Add(classifier.Action);
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs	(revision 9194)
@@ -34,6 +34,6 @@
       get { return (ILookupParameter<BoolValue>)Parameters["MatchAction"]; }
     }
-    public ILookupParameter<IClassifier> TargetMatchParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
+    public ILookupParameter<IAction> TargetMatchParameter {
+      get { return (ILookupParameter<IAction>)Parameters["TargetMatchParameter"]; }
     }
     public ILookupParameter<IClassifier> MatchParameter {
@@ -49,5 +49,5 @@
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("MatchAction", "True if the action matches."));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
+      Parameters.Add(new ValueLookupParameter<IAction>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
       Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
     }
@@ -57,5 +57,5 @@
 
     public override IOperation Apply() {
-      IClassifier target = TargetMatchParameter.ActualValue;
+      IAction target = TargetMatchParameter.ActualValue;
       IClassifier match = MatchParameter.ActualValue;
       MatchActionParameter.ActualValue = new BoolValue(match.MatchAction(target));
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9194)
@@ -34,6 +34,6 @@
       get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
     }
-    public ILookupParameter<IClassifier> TargetMatchParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
+    public ILookupParameter<IInput> TargetMatchParameter {
+      get { return (ILookupParameter<IInput>)Parameters["TargetMatchParameter"]; }
     }
     public ILookupParameter<IClassifier> MatchParameter {
@@ -49,5 +49,5 @@
       : base() {
       Parameters.Add(new LookupParameter<BoolValue>("MatchCondition", "True if the condition matches."));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
+      Parameters.Add(new ValueLookupParameter<IInput>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
       Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
     }
@@ -57,7 +57,7 @@
 
     public override IOperation Apply() {
-      IClassifier target = TargetMatchParameter.ActualValue;
+      IInput target = TargetMatchParameter.ActualValue;
       IClassifier match = MatchParameter.ActualValue;
-      MatchConditionParameter.ActualValue = new BoolValue(match.MatchCondition(target));
+      MatchConditionParameter.ActualValue = new BoolValue(match.MatchInput(target));
       return base.Apply();
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs	(revision 9194)
@@ -33,4 +33,7 @@
   public class PredictionArrayCalculator : SingleSuccessorOperator {
 
+    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
+      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
+    }
     public ILookupParameter<ItemArray<DoubleValue>> FitnessParameter {
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Fitness"]; }
@@ -39,6 +42,6 @@
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Prediction"]; }
     }
-    public IValueParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
-      get { return (IValueParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
+    public IValueParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
+      get { return (IValueParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
     }
     public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
@@ -53,7 +56,8 @@
     public PredictionArrayCalculator()
       : base() {
+      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitness"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Prediction"));
-      Parameters.Add(new ValueLookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
+      Parameters.Add(new ValueLookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
@@ -64,6 +68,6 @@
 
     public sealed override IOperation Apply() {
-      IItemDictionary<IClassifier, DoubleValue> predictionArray = new ItemDictionary<IClassifier, DoubleValue>();
-      IDictionary<IClassifier, double> fitnessSumPerAction = new Dictionary<IClassifier, double>();
+      IItemDictionary<IAction, DoubleValue> predictionArray = new ItemDictionary<IAction, DoubleValue>(ClassifierComparerParameter.ActualValue);
+      IDictionary<IAction, double> fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
       ItemArray<DoubleValue> fitnesses = FitnessParameter.ActualValue;
       ItemArray<DoubleValue> predictions = PredictionParameter.ActualValue;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs	(revision 9194)
@@ -33,9 +33,9 @@
 
     #region parameter
-    public IValueLookupParameter<IClassifier> SelectedActionParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    public IValueLookupParameter<IAction> SelectedActionParameter {
+      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
     }
-    public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
+    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
+      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
     }
     public IValueLookupParameter<DoubleValue> CurrentPayoffParameter {
@@ -61,6 +61,6 @@
     public ActionExecuter()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction"));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
+      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction"));
+      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentPayoff"));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("NegativeReward"));
@@ -69,5 +69,5 @@
 
     public override IOperation Apply() {
-      if (SelectedActionParameter.ActualValue.MatchAction(CurrentClassifierToMatchParameter.ActualValue)) {
+      if (SelectedActionParameter.ActualValue.Match(CurrentActionToMatchParameter.ActualValue)) {
         CurrentPayoffParameter.ActualValue = PositiveRewardParameter.ActualValue;
       } else {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ClassifierFetcher.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ClassifierFetcher.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ClassifierFetcher.cs	(revision 9194)
@@ -33,7 +33,11 @@
   [StorableClass]
   public class ClassifierFetcher : SingleSuccessorOperator, IClassifierFetcher {
+
     #region parameters
-    public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
+    public IValueLookupParameter<IInput> CurrentInputToMatchParameter {
+      get { return (IValueLookupParameter<IInput>)Parameters["CurrentConditionToMatch"]; }
+    }
+    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
+      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
     }
     public ILookupParameter<IConditionActionProblemData> ProblemDataParameter {
@@ -56,5 +60,6 @@
     public ClassifierFetcher()
       : base() {
-      Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
+      Parameters.Add(new ValueLookupParameter<IInput>("CurrentConditionToMatch"));
+      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
       Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData"));
       Parameters.Add(new LookupParameter<IntValue>("Iteration"));
@@ -68,5 +73,6 @@
       var trainingIndices = ProblemData.TrainingIndices.ToList();
       int index = IterationParameter.ActualValue.Value % trainingIndices.Count;
-      CurrentClassifierToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchClassifier(trainingIndices[index]);
+      CurrentInputToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchInput(trainingIndices[index]);
+      CurrentActionToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchAction(trainingIndices[index]);
       return base.Apply();
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs	(revision 9194)
@@ -27,6 +27,6 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface IActionExecuter : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
-    IValueLookupParameter<IClassifier> SelectedActionParameter { get; }
-    IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
+    IValueLookupParameter<IAction> SelectedActionParameter { get; }
+    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
     IValueLookupParameter<DoubleValue> CurrentPayoffParameter { get; }
     ILookupParameter<DoubleValue> NegativeRewardParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs	(revision 9194)
@@ -27,5 +27,6 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface IClassifierFetcher : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
-    IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
+    IValueLookupParameter<IInput> CurrentInputToMatchParameter { get; }
+    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
     ILookupParameter<IConditionActionProblemData> ProblemDataParameter { get; }
     ILookupParameter<IntValue> IterationParameter { get; }
Index: anches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/IMatchSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/IMatchSelector.cs	(revision 9193)
+++ 	(revision )
@@ -1,35 +1,0 @@
-﻿#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 System;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.Encodings.ConditionActionEncoding {
-  public interface IMatchSelector : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
-    BoolValue CopySelected { get; set; }
-    BoolValue MatchCondition { get; set; }
-    IValueLookupParameter<IntValue> NumberOfSelectedSubScopesParameter { get; }
-    ILookupParameter<IClassifier> TargetMatchParameter { get; }
-    ILookupParameter<ItemArray<IClassifier>> MatchParameter { get; }
-  }
-}
Index: anches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/MatchSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/MatchSelector.cs	(revision 9193)
+++ 	(revision )
@@ -1,102 +1,0 @@
-﻿#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 System.Collections.Generic;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Selection;
-
-namespace HeuristicLab.Encodings.ConditionActionEncoding {
-  /// <summary>
-  /// A class for selection operators which match a target to the scopes.
-  /// </summary>
-  [Item("MatchSelector", "A class for selection operators which match a target to the scopes.")]
-  [StorableClass]
-  public class MatchSelector : Selector, IMatchSelector {
-    protected IValueParameter<BoolValue> CopySelectedParameter {
-      get { return (IValueParameter<BoolValue>)Parameters["CopySelected"]; }
-    }
-    protected IValueParameter<BoolValue> MatchConditionParameter {
-      get { return (IValueParameter<BoolValue>)Parameters["MatchCondition"]; }
-    }
-    public IValueLookupParameter<IntValue> NumberOfSelectedSubScopesParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfSelectedSubScopes"]; }
-    }
-    public ILookupParameter<IClassifier> TargetMatchParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
-    }
-    public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
-      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
-    }
-    public BoolValue CopySelected {
-      get { return CopySelectedParameter.Value; }
-      set { CopySelectedParameter.Value = value; }
-    }
-
-    public BoolValue MatchCondition {
-      get { return MatchConditionParameter.Value; }
-      set { MatchConditionParameter.Value = value; }
-    }
-
-    [StorableConstructor]
-    protected MatchSelector(bool deserializing) : base(deserializing) { }
-    protected MatchSelector(MatchSelector original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new MatchSelector(this, cloner);
-    }
-
-    public MatchSelector()
-      : base() {
-      Parameters.Add(new ValueParameter<BoolValue>("CopySelected", "True if the selected sub-scopes should be copied, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<BoolValue>("MatchCondition", "True if the condition of the match paramteres have to match, otherwise the action has to match.", new BoolValue(true)));
-      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfSelectedSubScopes", "The number of sub-scopes which should be selected."));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
-      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
-    }
-
-    protected override IScope[] Select(List<IScope> scopes) {
-      IClassifier target = TargetMatchParameter.ActualValue;
-      List<IScope> matched = new List<IScope>();
-      for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
-        if (MatchingMethod(MatchParameter.ActualValue[i], target)) {
-          if (CopySelected.Value) {
-            matched.Add((IScope)scopes[i].Clone());
-          } else {
-            matched.Add(scopes[i]);
-          }
-        }
-      }
-      NumberOfSelectedSubScopesParameter.ActualValue = new IntValue(matched.Count);
-      return matched.ToArray();
-    }
-
-    private bool MatchingMethod(IClassifier iMatching, IClassifier target) {
-      if (MatchCondition.Value) {
-        return iMatching.MatchCondition(target);
-      } else {
-        return iMatching.MatchAction(target);
-      }
-    }
-  }
-}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs	(revision 9194)
@@ -105,5 +105,5 @@
       for (int i = 0; i < parents.Length; i++) {
         IClassifier curParent = parents[i];
-        if (curParent.MatchAction(child)) {
+        if (curParent.MatchAction(child.Action)) {
           if (CouldSubsume(experiences[i], errors[i])) {
             if (curParent.IsMoreGeneral(child)) {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSModel.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSModel.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSModel.cs	(revision 9194)
@@ -34,4 +34,6 @@
     public int ClassifierCount { get { return Count; } }
 
+    public IClassifierComparer ClassifierComparer { get; set; }
+
     [StorableConstructor]
     protected XCSModel(bool deserializing) : base(deserializing) { }
@@ -51,5 +53,5 @@
     }
 
-    public IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers) {
+    public IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers) {
       foreach (var classifier in classifiers) {
         yield return GetAction(classifier);
@@ -57,8 +59,8 @@
     }
 
-    public IClassifier GetAction(IClassifier classifier) {
+    public IAction GetAction(IInput classifier) {
       var matchedClassifiers = new ItemCollection<XCSClassifier>();
       foreach (var xcsClassifier in this) {
-        if (xcsClassifier.Classifier.MatchCondition(classifier)) {
+        if (xcsClassifier.Classifier.MatchInput(classifier)) {
           matchedClassifiers.Add(xcsClassifier);
         }
@@ -67,11 +69,11 @@
       if (matchedClassifiers.Count == 0) { return null; }
 
-      IDictionary<IClassifier, double> predictionArray = CreatePredictionArray(matchedClassifiers);
+      IDictionary<IAction, double> predictionArray = CreatePredictionArray(matchedClassifiers);
       return predictionArray.OrderByDescending(x => x.Value).First().Key;
     }
 
-    private IDictionary<IClassifier, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
-      var predictionArray = new Dictionary<IClassifier, double>();
-      var fitnessSumPerAction = new Dictionary<IClassifier, double>();
+    private IDictionary<IAction, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
+      var predictionArray = new Dictionary<IAction, double>(ClassifierComparer);
+      var fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparer);
 
       foreach (var xcsClassifier in matchedClassifiers) {
@@ -86,5 +88,5 @@
       }
 
-      var actions = new List<IClassifier>(predictionArray.Keys);
+      var actions = new List<IAction>(predictionArray.Keys);
       foreach (var action in actions) {
         if (fitnessSumPerAction[action] != 0) {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs	(revision 9194)
@@ -104,14 +104,17 @@
 
     private void RecalculateResults() {
-      var originalTrainingClassifer = ProblemData.FetchClassifier(ProblemData.TrainingIndices);
-      var originalTestClassifer = ProblemData.FetchClassifier(ProblemData.TestIndices);
-      var estimatedTrainingClassifier = Model.GetAction(originalTrainingClassifer);
-      var estimatedTestClassifier = Model.GetAction(originalTestClassifer);
-
-      TrainingAccuracy = CalculateAccuracy(originalTrainingClassifer, estimatedTrainingClassifier);
-      TestAccuracy = CalculateAccuracy(originalTestClassifer, estimatedTestClassifier);
-    }
-
-    private double CalculateAccuracy(IEnumerable<IClassifier> original, IEnumerable<IClassifier> estimated) {
+      var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
+      var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
+      var estimatedTrainingClassifier = Model.GetAction(originalTrainingCondition);
+      var estimatedTestClassifier = Model.GetAction(originalTestCondition);
+
+      var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);
+      var originalTestAction = ProblemData.FetchAction(ProblemData.TestIndices);
+
+      TrainingAccuracy = CalculateAccuracy(originalTrainingAction, estimatedTrainingClassifier);
+      TestAccuracy = CalculateAccuracy(originalTestAction, estimatedTestClassifier);
+    }
+
+    private double CalculateAccuracy(IEnumerable<IAction> original, IEnumerable<IAction> estimated) {
       double correctClassified = 0;
 
@@ -121,5 +124,5 @@
 
       while (originalEnumerator.MoveNext() && estimatedActionEnumerator.MoveNext()) {
-        if (originalEnumerator.Current.MatchAction(estimatedActionEnumerator.Current)) {
+        if (originalEnumerator.Current.Match(estimatedActionEnumerator.Current)) {
           correctClassified++;
         }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Creators/UniformRandomVariableVectorCreator.cs	(revision 9194)
@@ -0,0 +1,53 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector.Creators {
+  [Item("UniformRandomVariableVectorCreator", "Description missing")]
+  [StorableClass]
+  public class UniformRandomVariableVectorCreator : VariableVectorCreator {
+
+    #region Parameter Properties
+    #endregion
+
+    [StorableConstructor]
+    protected UniformRandomVariableVectorCreator(bool deserializing) : base(deserializing) { }
+    protected UniformRandomVariableVectorCreator(UniformRandomVariableVectorCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformRandomVariableVectorCreator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformRandomVariableVectorCreator(this, cloner);
+    }
+
+    protected override VariableVector Create(IRandom random, VariableVector sampleVariableVector, double spreadPercentage) {
+      var result = new VariableVector(sampleVariableVector.Condition.Values.Select(x => x.GetEmptyCopy()), sampleVariableVector.Action.Values.Select(x => x.GetEmptyCopy()));
+      result.Randomize(random, spreadPercentage);
+      return result;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9194)
@@ -0,0 +1,99 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector.Crossover {
+  [Item("SinglePointCrossover", "Description missing")]
+  [StorableClass]
+  public class SinglePointCrossover : VariableVectorCrossover {
+
+    #region Parameter Properties
+    #endregion
+
+    [StorableConstructor]
+    protected SinglePointCrossover(bool deserializing) : base(deserializing) { }
+    protected SinglePointCrossover(SinglePointCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SinglePointCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SinglePointCrossover(this, cloner);
+    }
+
+    public static VariableVector Apply(IRandom random, VariableVector parent1, VariableVector parent2) {
+      var parent1Condition = parent1.Condition;
+      var parent2Condition = parent2.Condition;
+
+      var parent1Action = parent1.Action;
+      var parent2Action = parent2.Action;
+
+      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)
+        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);
+
+      var keyEnumerator = parent1Condition.Keys.GetEnumerator();
+
+      int index = 0;
+      IVariable curVariable;
+      while (index < breakPoint) {
+        keyEnumerator.MoveNext();
+        curVariable = parent1Condition[keyEnumerator.Current];
+        if (curVariable.VirtualLength == 1 || index + curVariable.VirtualLength - 1 < breakPoint) {
+          newCondition.Add(curVariable.GetSetCopy());
+          index += curVariable.VirtualLength;
+        }
+      }
+
+      // breakpoint is in between a variable
+      if (index != breakPoint) {
+        newCondition.Add(parent1Condition[keyEnumerator.Current].CrossParentsAtPosition(parent2Condition[keyEnumerator.Current], breakPoint - index - 1));
+      }
+
+      while (index < conditionLength) {
+        keyEnumerator.MoveNext();
+        curVariable = parent2Condition[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());
+
+      return new VariableVector(newCondition, action);
+    }
+
+    protected override VariableVector Cross(IRandom random, ItemArray<VariableVector> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
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 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9194)
@@ -0,0 +1,126 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{7C116F48-7218-4105-BD6E-EE868E2D4823}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.VariableVector</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.VariableVector-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorCrossover.cs" />
+    <Compile Include="VariableVectorCrossover.cs" />
+    <Compile Include="Variable\IActionVariable.cs" />
+    <Compile Include="Variable\IVariable.cs" />
+    <Compile Include="VariableVectorAction.cs" />
+    <Compile Include="Creators\UniformRandomVariableVectorCreator.cs" />
+    <Compile Include="Variable\DoubleVariable.cs" />
+    <Compile Include="Interfaces\IVariableVectorCreator.cs" />
+    <Compile Include="Interfaces\IVariableVectorOperator.cs" />
+    <Compile Include="Variable\IntVariable.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Variable\StringVariable.cs" />
+    <Compile Include="Variable\Variable.cs" />
+    <Compile Include="VariableVector.cs" />
+    <Compile Include="VariableVectorCondition.cs" />
+    <Compile Include="VariableVectorCreator.cs" />
+    <Compile Include="VariableVectorInput.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Plugin.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
+      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
+      <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs	(revision 9194)
@@ -0,0 +1,33 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorCreator : ISolutionCreator, IVariableVectorOperator {
+    IValueLookupParameter<PercentValue> SpreadPercentageParameter { get; }
+    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+    ILookupParameter<VariableVector> VariableVectorParameter { get; }
+
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCrossover.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCrossover.cs	(revision 9194)
@@ -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.Optimization;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorCrossover : ICrossover, IVariableVectorOperator {
+    ILookupParameter<ItemArray<VariableVector>> ParentsParameter { get; }
+    ILookupParameter<VariableVector> ChildParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorOperator.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorOperator.cs	(revision 9194)
@@ -0,0 +1,27 @@
+﻿#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;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorOperator : IOperator {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs.frame	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs.frame	(revision 9194)
@@ -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.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Encodings.VariableVector-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  public class HeuristicLabEncodingsVariableVectorPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs.frame	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs.frame	(revision 9194)
@@ -0,0 +1,57 @@
+﻿#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 System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Encodings.VariableVector-3.3")]
+[assembly: AssemblyDescription("Encoding with variables")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("d591186d-c10f-42ea-bc8f-a079a978e793")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9194)
@@ -0,0 +1,162 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item(Name = "DoubleVariable", Description = "")]
+  public class DoubleVariable : Variable<double> {
+    public override int VirtualLength {
+      get { return 2; }
+    }
+
+    [Storable]
+    protected double min;
+    public double Min {
+      get { return min; }
+    }
+    [Storable]
+    protected double max;
+    public double Max {
+      get { return max; }
+    }
+
+    [Storable]
+    protected double currentCenter;
+    public double CurrentCenter {
+      get { return currentCenter; }
+      set { currentCenter = value; }
+    }
+
+    [Storable]
+    protected double currentSpread;
+    public double CurrentSpread {
+      get { return currentSpread; }
+      set { currentSpread = value; }
+    }
+
+    [StorableConstructor]
+    protected DoubleVariable(bool deserializing) : base(deserializing) { }
+    protected DoubleVariable(DoubleVariable original, Cloner cloner)
+      : base(original, cloner) {
+      min = original.min;
+      max = original.max;
+    }
+    public DoubleVariable() : base() { }
+    public DoubleVariable(string variableName, IEnumerable<double> variableValues)
+      : base(variableName) {
+      min = variableValues.Min();
+      max = variableValues.Max();
+    }
+    protected DoubleVariable(string variableName, double min, double max)
+      : base(variableName) {
+      this.min = min;
+      this.max = max;
+    }
+    public DoubleVariable(string variableName, IEnumerable<double> variableValues, double center, double spread)
+      : this(variableName, variableValues) {
+      CurrentCenter = center;
+      CurrentSpread = spread;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoubleVariable(this, cloner);
+    }
+
+    public override string ToString() {
+      return (currentCenter - currentCenter) + " - " + (currentCenter + currentSpread);
+    }
+
+    public override bool MatchInput(string target) {
+      return Match(Double.Parse(target));
+    }
+
+    public override bool Match(double target) {
+      return currentCenter - currentSpread < target && target < currentCenter + currentSpread;
+    }
+
+    public new DoubleVariable GetEmptyCopy() {
+      return new DoubleVariable(variableName, min, max);
+    }
+    public new DoubleVariable GetSetCopy() {
+      DoubleVariable copy = GetEmptyCopy();
+      copy.CurrentCenter = this.CurrentCenter;
+      copy.CurrentSpread = this.CurrentSpread;
+      return copy;
+    }
+
+    // Important! If this mehtod is called instead of the more concrete "Randomize(IRandom random, double spreadPercentage)"
+    // spread percentage is 50%
+    public override void Randomize(IRandom random) {
+      Randomize(random, 50);
+    }
+
+    public void Randomize(IRandom random, double spreadPercentage) {
+      if (spreadPercentage < 0 || spreadPercentage > 100) {
+        throw new ArgumentException("Spread percentage has to be between 0 and 100.");
+      }
+      double delta = Max - Min;
+      CurrentCenter = random.NextDouble() * delta + Min;
+      CurrentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+    }
+
+    public override bool Identical(IVariable target) {
+      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; }
+
+      return true;
+    }
+
+    public override double GetGenerality() {
+      double delta = max - min;
+      double intervalWidth = 2 * currentSpread;
+      double generality = intervalWidth / delta;
+      return generality > 1 ? 1 : generality;
+    }
+
+    public override bool IsGreaterThanOrEquallyGeneral(IVariable target) {
+      var targetCast = target as DoubleVariable;
+      if (targetCast == null) { return false; }
+      return currentCenter - currentSpread < targetCast.currentCenter - targetCast.currentSpread
+        && currentCenter + currentSpread > targetCast.currentCenter + targetCast.currentSpread;
+    }
+
+    public new DoubleVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+      var 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 = this.GetSetCopy();
+      if (pos == 0) {
+        crossed.CurrentSpread = parent2Cast.CurrentSpread;
+      }
+      return crossed;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IActionVariable.cs	(revision 9194)
@@ -0,0 +1,27 @@
+﻿#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
+
+
+namespace HeuristicLab.Encodings.VariableVector {
+  // variables which can be used in the action
+  public interface IActionVariable : IVariable {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9194)
@@ -0,0 +1,44 @@
+﻿#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 System;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariable : IItem {
+    string VariableName { get; }
+    int VirtualLength { get; }
+    Type VariableType { get; }
+
+    IVariable GetEmptyCopy();
+    IVariable GetSetCopy();
+    void Randomize(IRandom random);
+    bool MatchInput(string target);
+    bool MatchVariable(IVariable target);
+
+    bool Identical(IVariable target);
+
+    double GetGenerality();
+    bool IsGreaterThanOrEquallyGeneral(IVariable target);
+
+    IVariable CrossParentsAtPosition(IVariable parent2, int pos);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9194)
@@ -0,0 +1,148 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item(Name = "IntVariable", Description = "")]
+  public class IntVariable : Variable<int>, IActionVariable {
+
+    public override int VirtualLength {
+      get { return 1; }
+    }
+
+    [Storable]
+    public bool Wildcard { get; set; }
+
+    [Storable]
+    protected IEnumerable<int> possibleFeatures;
+    public IEnumerable<int> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [Storable]
+    protected int currentValue;
+    public int CurrentValue {
+      get { return currentValue; }
+      set {
+        if (!possibleFeatures.Contains(value)) {
+          throw new ArgumentException("Value is not a possible feature of this variable.");
+        }
+        currentValue = value;
+      }
+    }
+
+    [StorableConstructor]
+    protected IntVariable(bool deserializing) : base(deserializing) { }
+    protected IntVariable(IntVariable original, Cloner cloner)
+      : base(original, cloner) {
+      this.possibleFeatures = new List<int>(original.possibleFeatures);
+      this.Wildcard = original.Wildcard;
+    }
+    public IntVariable()
+      : base() {
+      Wildcard = false;
+    }
+    public IntVariable(string variableName, IEnumerable<int> variableValues)
+      : base(variableName) {
+      if (variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct.");
+      }
+      possibleFeatures = variableValues;
+      Wildcard = false;
+    }
+    public IntVariable(string variableName, IEnumerable<int> variableValues, int currentValue)
+      : this(variableName, variableValues) {
+      CurrentValue = currentValue;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntVariable(this, cloner);
+    }
+
+    public override string ToString() {
+      return currentValue.ToString();
+    }
+
+    public override bool MatchInput(string target) {
+      return Match(int.Parse(target));
+    }
+
+    public override bool Match(int target) {
+      return Wildcard || CurrentValue == target;
+    }
+
+    public override bool MatchVariable(IVariable target) {
+      var targetCast = target as IntVariable;
+      return targetCast != null && this.variableName.Equals(targetCast.VariableName) && Match(targetCast.CurrentValue);
+    }
+
+    public new IntVariable GetEmptyCopy() {
+      return new IntVariable(variableName, possibleFeatures);
+    }
+    public new IntVariable GetSetCopy() {
+      IntVariable copy = GetEmptyCopy();
+      copy.Wildcard = this.Wildcard;
+      copy.CurrentValue = this.CurrentValue;
+      return copy;
+    }
+
+    public override void Randomize(IRandom random) {
+      int index = random.Next(possibleFeatures.Count());
+      currentValue = possibleFeatures.ElementAt(index);
+    }
+
+    public override bool Identical(IVariable target) {
+      var targetCast = target as IntVariable;
+      if (targetCast == null) { return false; }
+      if (variableName != targetCast.variableName || Wildcard != targetCast.Wildcard
+        || currentValue != targetCast.currentValue) { return false; }
+
+      if (possibleFeatures.Except(targetCast.possibleFeatures).Count() != 0
+        || targetCast.possibleFeatures.Except(possibleFeatures).Count() != 0) { return false; }
+
+      return true;
+    }
+
+    public override double GetGenerality() {
+      return Wildcard ? 1 : 0;
+    }
+
+    public override bool IsGreaterThanOrEquallyGeneral(IVariable target) {
+      var targetCast = target as IntVariable;
+      if (targetCast == null) { return false; }
+      return Wildcard || currentValue == targetCast.currentValue;
+    }
+
+    public new IntVariable 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 this.GetSetCopy();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9194)
@@ -0,0 +1,200 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item(Name = "StringVariable", Description = "")]
+  public class StringVariable : Variable<string>, IActionVariable {
+
+    public override int VirtualLength {
+      get { return 1; }
+    }
+
+    [Storable]
+    public bool Wildcard { get; set; }
+
+    [Storable]
+    protected IEnumerable<int> possibleFeatures;
+    public IEnumerable<int> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [Storable]
+    protected IDictionary<int, string> featureMapping;
+    public IDictionary<int, string> FeatureMapping {
+      get { return featureMapping; }
+    }
+
+    [Storable]
+    protected int currentValue;
+    public int CurrentValue {
+      get { return currentValue; }
+      set {
+        if (!possibleFeatures.Contains(value)) {
+          throw new ArgumentException("Value is not a possible feature of this variable.");
+        }
+        currentValue = value;
+      }
+    }
+
+    public string CurrentStringValue {
+      get { return featureMapping[currentValue]; }
+    }
+
+    [StorableConstructor]
+    protected StringVariable(bool deserializing) : base(deserializing) { }
+    protected StringVariable(StringVariable original, Cloner cloner)
+      : base(original, cloner) {
+      this.possibleFeatures = new List<int>(original.possibleFeatures);
+      this.featureMapping = new Dictionary<int, string>(original.featureMapping);
+      this.Wildcard = original.Wildcard;
+    }
+    public StringVariable()
+      : base() {
+      Wildcard = false;
+    }
+    public StringVariable(string variableName, IEnumerable<string> variableValues)
+      : base(variableName) {
+      if (variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct.");
+      }
+      featureMapping = new Dictionary<int, string>();
+      var distinctValuesEnumerator = variableValues.Distinct().GetEnumerator();
+      possibleFeatures = Enumerable.Range(0, featureMapping.Count());
+      var possibleFeaturesEnumerator = possibleFeatures.GetEnumerator();
+      while (possibleFeaturesEnumerator.MoveNext() && distinctValuesEnumerator.MoveNext()) {
+        featureMapping.Add(possibleFeaturesEnumerator.Current, distinctValuesEnumerator.Current);
+      }
+      Wildcard = false;
+    }
+    public StringVariable(string variableName, IEnumerable<string> variableValues, string currentValue)
+      : this(variableName, variableValues) {
+      int index = 0;
+      foreach (var feature in featureMapping) {
+        if (feature.Equals(currentValue)) {
+          break;
+        }
+        index++;
+      }
+      if (index > featureMapping.Count()) { throw new ArgumentException("variableValues do not contain currentValue."); }
+      CurrentValue = index;
+    }
+    public StringVariable(string variableName, IDictionary<int, string> featureMapping)
+      : base(variableName) {
+      if (featureMapping.Values.Count != featureMapping.Values.Distinct().Count()) {
+        throw new ArgumentException("featureMapping values have to be distinct.");
+      }
+      this.possibleFeatures = featureMapping.Keys;
+      this.featureMapping = featureMapping;
+      Wildcard = false;
+    }
+    public StringVariable(string variableName, IDictionary<int, string> featureMapping, string currentValue)
+      : this(variableName, featureMapping) {
+      bool found = false;
+      foreach (var pair in featureMapping) {
+        if (pair.Value.Equals(currentValue)) {
+          CurrentValue = pair.Key;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        throw new ArgumentException("variableValues do not contain currentValue.");
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StringVariable(this, cloner);
+    }
+
+    public override string ToString() {
+      return CurrentStringValue;
+    }
+
+    public override bool MatchInput(string target) {
+      return Wildcard || featureMapping[CurrentValue].Equals(target);
+    }
+
+    public override bool Match(string target) {
+      return MatchInput(target);
+    }
+
+    public override bool MatchVariable(IVariable target) {
+      var targetCast = target as StringVariable;
+      return targetCast != null && this.variableName.Equals(targetCast.VariableName) && Match(targetCast.CurrentStringValue);
+    }
+
+    public new StringVariable GetEmptyCopy() {
+      return new StringVariable(variableName, featureMapping);
+    }
+    public new StringVariable GetSetCopy() {
+      StringVariable copy = GetEmptyCopy();
+      copy.Wildcard = this.Wildcard;
+      copy.CurrentValue = this.CurrentValue;
+      return copy;
+    }
+
+    public override void Randomize(IRandom random) {
+      int index = random.Next(possibleFeatures.Count());
+      currentValue = possibleFeatures.ElementAt(index);
+    }
+
+    public override bool Identical(IVariable target) {
+      var targetCast = target as StringVariable;
+      if (targetCast == null) { return false; }
+      if (variableName != targetCast.variableName || Wildcard != targetCast.Wildcard
+        || currentValue != targetCast.currentValue) { return false; }
+
+      if (featureMapping.Keys.Except(targetCast.featureMapping.Keys).Count() != 0
+        || targetCast.featureMapping.Keys.Except(featureMapping.Keys).Count() != 0) { return false; }
+
+      foreach (var keyValuePair in targetCast.featureMapping) {
+        if (!featureMapping[keyValuePair.Key].Equals(keyValuePair.Value)) { return false; }
+      }
+
+      return true;
+    }
+
+    public override double GetGenerality() {
+      return Wildcard ? 1 : 0;
+    }
+
+    public override bool IsGreaterThanOrEquallyGeneral(IVariable target) {
+      var targetCast = target as StringVariable;
+      if (targetCast == null) { return false; }
+      return Wildcard || (currentValue == targetCast.currentValue && CurrentStringValue.Equals(targetCast.CurrentStringValue));
+    }
+
+    public new StringVariable 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 this.GetSetCopy();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9194)
@@ -0,0 +1,72 @@
+﻿#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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("Variable", "")]
+  [StorableClass]
+  public abstract class Variable<T> : Item, IVariable {
+
+    [Storable]
+    protected string variableName;
+    public string VariableName {
+      get { return variableName; }
+    }
+
+    public abstract int VirtualLength { get; }
+
+    public Type VariableType { get { return typeof(T); } }
+
+    [StorableConstructor]
+    protected Variable(bool deserializing) : base(deserializing) { }
+    protected Variable(Variable<T> original, Cloner cloner)
+      : base(original, cloner) {
+      this.variableName = (string)original.variableName.Clone();
+    }
+    public Variable() : base() { }
+    public Variable(string variableName)
+      : base() {
+      this.variableName = variableName;
+    }
+
+    public virtual IVariable GetEmptyCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
+    public virtual IVariable GetSetCopy() { throw new NotSupportedException("This method is not supported. It should be implemented by every non abstract class."); }
+
+    public abstract void Randomize(IRandom random);
+
+    public virtual bool MatchVariable(IVariable target) { throw new NotSupportedException("This method is not supported by this kind of Variable."); }
+    public abstract bool Match(T target);
+
+    public abstract bool MatchInput(string target);
+
+    public abstract bool Identical(IVariable target);
+
+    public abstract double GetGenerality();
+
+    public abstract bool IsGreaterThanOrEquallyGeneral(IVariable target);
+
+    public virtual IVariable CrossParentsAtPosition(IVariable parent2, int pos) { throw new NotSupportedException("This method is not supported."); }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9194)
@@ -0,0 +1,134 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item("VariableVector", "")]
+  public class VariableVector : Item, IClassifier {
+    [Storable]
+    protected VariableVectorCondition condition;
+    public VariableVectorCondition Condition { get { return condition; } }
+
+    [Storable]
+    protected VariableVectorAction action;
+    public VariableVectorAction Action { get { return action; } }
+
+    public int Count {
+      get { return condition.Count + action.Count; }
+    }
+
+    public int VirtualLength {
+      get { return condition.Values.Sum(x => x.VirtualLength) + action.Values.Sum(x => x.VirtualLength); }
+    }
+
+    [StorableConstructor]
+    protected VariableVector(bool deserializing) : base(deserializing) { }
+    protected VariableVector(VariableVector original, Cloner cloner)
+      : base(original, cloner) {
+      condition = new VariableVectorCondition(original.condition);
+      action = new VariableVectorAction(original.action);
+    }
+    public VariableVector() {
+      condition = new VariableVectorCondition();
+      action = new VariableVectorAction();
+    }
+    public VariableVector(IEnumerable<IVariable> condition, IEnumerable<IVariable> action)
+      : this() {
+      if (condition == null || action == null) { throw new ArgumentNullException(); }
+      if (action.All(x => x is IActionVariable)) { throw new ArgumentException("Action can only use IActionVariable"); }
+      this.Condition.Add(condition);
+      this.Action.Add(action.Cast<IActionVariable>());
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVector(this, cloner);
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      sb.Append("[");
+      sb.Append(condition.ToString());
+      sb.Append("||");
+      sb.Append(action.ToString());
+      sb.Append("]");
+      return sb.ToString();
+    }
+
+    public void Randomize(IRandom random, double spreadPercentage) {
+      condition.Randomize(random, spreadPercentage);
+      action.Randomize(random);
+    }
+
+    ICondition IClassifier.Condition {
+      get { return Condition; }
+    }
+
+    IAction IClassifier.Action {
+      get { return Action; }
+    }
+
+    public bool MatchInput(IInput target) {
+      return Condition.Match(target);
+    }
+
+    public bool MatchAction(IAction target) {
+      return Action.Match(target);
+    }
+
+    public bool IsMoreGeneral(IClassifier target) {
+      return IsMoreGeneral(target.Condition);
+    }
+
+    public bool IsMoreGeneral(ICondition target) {
+      var targetCast = target as VariableVector;
+      if (targetCast == null) { return false; }
+      if (Condition.Keys.Except(targetCast.Condition.Keys).Count() != 0
+        || targetCast.Condition.Keys.Except(Condition.Keys).Count() != 0) { return false; }
+
+      double thisGenerality = Condition.Values.Sum(x => x.GetGenerality());
+      double targetGenerality = Condition.Values.Sum(x => x.GetGenerality());
+      if (thisGenerality <= targetGenerality) { return false; }
+
+      foreach (var variables in targetCast.Condition) {
+        if (!Condition[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    public bool Identical(IClassifier target) {
+      var targetCast = target as VariableVector;
+      if (targetCast == null) { return false; }
+      if (!condition.Identical(targetCast.condition)) { return false; }
+      if (!action.Identical(targetCast.condition)) { return false; }
+      return true;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9194)
@@ -0,0 +1,108 @@
+﻿#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 System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item("VariableVectorAction", "")]
+  public class VariableVectorAction : ItemDictionary<StringValue, IActionVariable>, IAction {
+
+    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+
+    [StorableConstructor]
+    protected VariableVectorAction(bool deserializing) : base(deserializing) { }
+    protected VariableVectorAction(VariableVectorAction original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorAction() : base() { }
+    public VariableVectorAction(int capacity) : base(capacity) { }
+    public VariableVectorAction(IDictionary<StringValue, IActionVariable> dictionary) : base(dictionary) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorAction(this, cloner);
+    }
+
+    protected override void OnItemsAdded(IEnumerable<KeyValuePair<StringValue, 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'");
+        }
+      }
+      base.OnItemsAdded(items);
+    }
+
+    public bool Match(IAction target) {
+      var targetCast = target as VariableVectorAction;
+      if (targetCast == null) { return false; }
+      if (!(this.Keys.Except(targetCast.Keys).Count() == 0 && targetCast.Keys.Except(this.Keys).Count() == 0)) { return false; }
+      foreach (var keyValuePair in targetCast) {
+        if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    public void Add(IEnumerable<IActionVariable> action) {
+      foreach (var variable in action) {
+        this.Add(new StringValue(variable.VariableName), variable);
+      }
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      bool first = true;
+      foreach (var variable in this.Values) {
+        if (!first) {
+          first = false;
+        } else {
+          sb.Append(";");
+        }
+        sb.Append(variable.ToString());
+      }
+      return sb.ToString();
+    }
+
+    public void Randomize(IRandom random) {
+      foreach (var variable in this.Values) {
+        variable.Randomize(random);
+      }
+    }
+
+    public bool Identical(VariableVectorCondition target) {
+      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      foreach (var keyValuePair in target) {
+        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9194)
@@ -0,0 +1,102 @@
+﻿#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 System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item("VariableVectorCondition", "")]
+  public class VariableVectorCondition : ItemDictionary<StringValue, IVariable>, ICondition {
+
+    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+
+    [StorableConstructor]
+    protected VariableVectorCondition(bool deserializing) : base(deserializing) { }
+    protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorCondition() : base() { }
+    public VariableVectorCondition(int capacity) : base(capacity) { }
+    public VariableVectorCondition(IDictionary<StringValue, IVariable> dictionary) : base(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 (!(targetCast.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(targetCast.Keys).Count() == 0)) { return false; }
+      foreach (var keyValuePair in targetCast) {
+        if (!this[keyValuePair.Key].MatchInput(keyValuePair.Value.Value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    public void Add(IEnumerable<IVariable> condition) {
+      foreach (var variable in condition) {
+        this.Add(new StringValue(variable.VariableName), variable);
+      }
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      bool first = true;
+      foreach (var variable in this.Values) {
+        if (!first) {
+          first = false;
+        } else {
+          sb.Append(";");
+        }
+        sb.Append(variable.ToString());
+      }
+      return sb.ToString();
+    }
+
+    public void Randomize(IRandom random, double spreadPercentage) {
+      foreach (var variable in this.Values) {
+        if (variable is DoubleVariable) {
+          ((DoubleVariable)variable).Randomize(random, spreadPercentage);
+        } else {
+          variable.Randomize(random);
+        }
+      }
+    }
+
+    public bool Identical(VariableVectorCondition target) {
+      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      foreach (var keyValuePair in target) {
+        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs	(revision 9194)
@@ -0,0 +1,70 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("VariableVectorCreator", "Description missing")]
+  [StorableClass]
+  public abstract class VariableVectorCreator : SingleSuccessorOperator, IVariableVectorCreator, IStochasticOperator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<PercentValue> SpreadPercentageParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["SpreadPercentage"]; }
+    }
+    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
+      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    }
+    public ILookupParameter<VariableVector> VariableVectorParameter {
+      get { return (ILookupParameter<VariableVector>)Parameters["VariableVector"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected VariableVectorCreator(bool deserializing) : base(deserializing) { }
+    protected VariableVectorCreator(VariableVectorCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorCreator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<PercentValue>("SpreadPercentage", ""));
+      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector", ""));
+      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."));
+    }
+
+    public override IOperation Apply() {
+      VariableVectorParameter.ActualValue = Create(RandomParameter.ActualValue, SampleVariableVectorParameter.ActualValue, SpreadPercentageParameter.ActualValue.Value);
+      return base.Apply();
+    }
+
+    protected abstract VariableVector Create(IRandom random, VariableVector sampleVariableVector, double spreadPercentage);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCrossover.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCrossover.cs	(revision 9194)
@@ -0,0 +1,69 @@
+﻿#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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("VariableVectorCrossover", "Description missing")]
+  [StorableClass]
+  public abstract class VariableVectorCrossover : SingleSuccessorOperator, IVariableVectorCrossover {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<VariableVector>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<VariableVector>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<VariableVector> ChildParameter {
+      get { return (ILookupParameter<VariableVector>)Parameters["Child"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected VariableVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected VariableVectorCrossover(VariableVectorCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new ScopeTreeLookupParameter<VariableVector>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "VariableVector";
+      Parameters.Add(new LookupParameter<VariableVector>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "VariableVector";
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract VariableVector Cross(IRandom random, ItemArray<VariableVector> parents);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9194)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9194)
@@ -0,0 +1,46 @@
+﻿#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 System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [StorableClass]
+  [Item("VariableVectorInput", "")]
+  public class VariableVectorInput : ItemDictionary<StringValue, StringValue>, IInput {
+
+    [StorableConstructor]
+    protected VariableVectorInput(bool deserializing) : base(deserializing) { }
+    protected VariableVectorInput(VariableVectorInput original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorInput() : base() { }
+    public VariableVectorInput(int capacity) : base(capacity) { }
+    public VariableVectorInput(IDictionary<StringValue, StringValue> dictionary) : base(dictionary) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorInput(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9194)
@@ -44,8 +44,4 @@
     <Reference Include="HeuristicLab.Common-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Core-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -100,4 +96,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9194)
@@ -69,6 +69,6 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialFitness"]; }
     }
-    public IFixedValueParameter<ItemSet<IClassifier>> PossibleActionsParameter {
-      get { return (IFixedValueParameter<ItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    public IFixedValueParameter<ItemSet<IAction>> PossibleActionsParameter {
+      get { return (IFixedValueParameter<ItemSet<IAction>>)Parameters["PossibleActions"]; }
     }
     public IFixedValueParameter<ItemSet<CombinedIntegerVector>> PossibleActionsConcreteClassParameter {
@@ -77,4 +77,7 @@
     public IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
+    }
+    public IFixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer> ClassifierComparerParameter {
+      get { return (IFixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer>)Parameters["ClassifierComparer"]; }
     }
     #endregion
@@ -108,5 +111,5 @@
     //  get { return PossibleActions; }
     //}
-    public ItemSet<IClassifier> PossibleActions {
+    public ItemSet<IAction> PossibleActions {
       get { return PossibleActionsParameter.Value; }
     }
@@ -148,4 +151,10 @@
     IParameter IConditionActionProblem.CoveringSolutionCreatorParameter {
       get { return CoveringSolutionCreatorParameter; }
+    }
+    public IClassifierComparer ClassifierComparer {
+      get { return ClassifierComparerParameter.Value; }
+    }
+    IParameter IConditionActionProblem.ClassifierComparerParameter {
+      get { return ClassifierComparerParameter; }
     }
     #endregion
@@ -177,6 +186,7 @@
       Parameters.Add(new ValueParameter<IActionExecuter>(ActionExecuterParameterName, "", new ActionExecuter()));
       Parameters.Add(new ValueParameter<ClassifierFetcher>(ClassifierFetcherParameterName, "", new ClassifierFetcher()));
-      Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
-      Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass"));
+      Parameters.Add(new FixedValueParameter<HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer>("ClassifierComparer", new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.CombinedIntegerVector.CombinedIntegerVectorComparer()));
+      Parameters.Add(new FixedValueParameter<ItemSet<IAction>>("PossibleActions", new ItemSet<IAction>(ClassifierComparer)));
+      Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass", new ItemSet<CombinedIntegerVector>(ClassifierComparer)));
       Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure.", new IntValue(1)));
 
@@ -191,10 +201,10 @@
 
       coveringSolutionCreator.ChangeSymbolProbabilityParameter.ActualName = ChangeSymbolProbabilityInCoveringParameter.Name;
-      coveringSolutionCreator.CoverClassifierParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      coveringSolutionCreator.CoverInputParameter.ActualName = ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
       coveringSolutionCreator.CreatedClassifierParameter.ActualName = "CombinedIntegerVector";
 
       ClassifierFetcher.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
 
-      ActionExecuter.CurrentClassifierToMatchParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      ActionExecuter.CurrentActionToMatchParameter.ActualName = ClassifierFetcher.CurrentActionToMatchParameter.ActualName;
       ActionExecuter.NegativeRewardParameter.ActualName = NegativeRewardParameter.Name;
       ActionExecuter.PositiveRewardParameter.ActualName = PositiveRewardParameter.Name;
@@ -241,4 +251,5 @@
         xcsAnalyzer.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
         xcsAnalyzer.ResultsParameter.ActualName = "Results";
+        xcsAnalyzer.ClassifierComparerParameter.ActualName = ClassifierComparerParameter.Name;
       }
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs	(revision 9194)
@@ -119,7 +119,4 @@
     #endregion
 
-    private IDictionary<int, IClassifier> fetchClassifiersCache = new Dictionary<int, IClassifier>();
-
-
     [StorableConstructor]
     protected ConditionActionClassificationProblemData(bool deserializing) : base(deserializing) { }
@@ -201,11 +198,24 @@
     }
 
-    public IEnumerable<IClassifier> FetchClassifier(IEnumerable<int> rows) {
+    public IEnumerable<IInput> FetchInput(IEnumerable<int> rows) {
       foreach (var row in rows) {
-        yield return FetchClassifier(row);
-      }
-    }
-
-    public IClassifier FetchClassifier(int rowNumber) {
+        yield return FetchInput(row);
+      }
+    }
+    public IInput FetchInput(int rowNumber) {
+      return FetchClassifier(rowNumber).Condition as IInput;
+    }
+    public IEnumerable<IAction> FetchAction(IEnumerable<int> rows) {
+      foreach (var row in rows) {
+        yield return FetchAction(row);
+      }
+    }
+    public IAction FetchAction(int rowNumber) {
+      return FetchClassifier(rowNumber).Action;
+    }
+    #region fetchHelper
+    private IDictionary<int, IClassifier> fetchClassifiersCache = new Dictionary<int, IClassifier>();
+
+    private IClassifier FetchClassifier(int rowNumber) {
       if (!fetchClassifiersCache.ContainsKey(rowNumber)) {
         int[] elements = new int[Length.Value];
@@ -231,4 +241,5 @@
       return fetchClassifiersCache[rowNumber];
     }
+    #endregion
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification.csproj	(revision 9194)
@@ -39,5 +39,4 @@
   <ItemGroup>
     <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
@@ -67,4 +66,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
       <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.XCS.Views/3.3/HeuristicLab.Problems.XCS.Views-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.XCS.Views/3.3/HeuristicLab.Problems.XCS.Views-3.3.csproj	(revision 9193)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.XCS.Views/3.3/HeuristicLab.Problems.XCS.Views-3.3.csproj	(revision 9194)
@@ -41,5 +41,4 @@
     <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
-    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.MainForm-3.3">
@@ -78,4 +77,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
       <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
Index: /branches/LearningClassifierSystems/LearningClassifierSystem.sln
===================================================================
--- /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9193)
+++ /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9194)
@@ -19,4 +19,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.ConditionActionClassification", "HeuristicLab.Problems.Instances.ConditionActionClassification\3.3\HeuristicLab.Problems.Instances.ConditionActionClassification.csproj", "{1CC7585E-DD22-41FA-869B-93DE41EA8936}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Core-3.3", "HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj", "{C36BD924-A541-4A00-AFA8-41701378DDC5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.VariableVector-3.3", "HeuristicLab.Encodings.VariableVector\3.3\HeuristicLab.Encodings.VariableVector-3.3.csproj", "{7C116F48-7218-4105-BD6E-EE868E2D4823}"
 EndProject
 Global
@@ -82,4 +86,24 @@
 		{1CC7585E-DD22-41FA-869B-93DE41EA8936}.Release|x64.ActiveCfg = Release|Any CPU
 		{1CC7585E-DD22-41FA-869B-93DE41EA8936}.Release|x86.ActiveCfg = Release|Any CPU
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x64.ActiveCfg = Debug|x64
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x64.Build.0 = Debug|x64
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x86.ActiveCfg = Debug|x86
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Debug|x86.Build.0 = Debug|x86
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x64.ActiveCfg = Release|x64
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x64.Build.0 = Release|x64
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x86.ActiveCfg = Release|x86
+		{C36BD924-A541-4A00-AFA8-41701378DDC5}.Release|x86.Build.0 = Release|x86
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x64.ActiveCfg = Release|Any CPU
+		{7C116F48-7218-4105-BD6E-EE868E2D4823}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
