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 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj	(revision 9089)
@@ -96,13 +96,9 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ActionSelection\ActionSelector.cs" />
-    <Compile Include="ActionSelection\MaxValueActionSelector.cs" />
-    <Compile Include="ActionSelection\RandomActionSelector.cs" />
+    <Compile Include="LCSAdaptedGeneticAlgorithm.cs" />
     <Compile Include="LearningClassifierSystem.cs" />
     <Compile Include="LearningClassifierSystemMainLoop.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Selectors\IMatchSelector.cs" />
-    <Compile Include="Selectors\MatchSelector.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
@@ -115,4 +111,12 @@
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
       <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-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>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.ConditionActionClassification\3.3\HeuristicLab.Problems.ConditionActionClassification-3.3.csproj">
+      <Project>{EA51D441-F6A3-41E1-9993-A2488E93C222}</Project>
+      <Name>HeuristicLab.Problems.ConditionActionClassification-3.3</Name>
     </ProjectReference>
   </ItemGroup>
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9089)
@@ -0,0 +1,230 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+namespace HeuristicLab.Algorithms.LearningClassifierSystems {
+  /// <summary>
+  /// An operator which represents the main loop of a genetic algorithm.
+  /// </summary>
+  [Item("LCSAdaptedGeneticAlgorithm", "An operator which represents the main loop of a genetic algorithm, which has been adapdet for learning classifier systems.")]
+  [StorableClass]
+  public sealed class LCSAdaptedGeneticAlgorithm : AlgorithmOperator {
+    #region Parameter properties
+    public ValueLookupParameter<IRandom> RandomParameter {
+      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ValueLookupParameter<IOperator> SelectorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Selector"]; }
+    }
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
+    }
+    public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Mutator"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    }
+    public ValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    public ValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ValueLookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    private ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private LCSAdaptedGeneticAlgorithm(bool deserializing) : base(deserializing) { }
+    private LCSAdaptedGeneticAlgorithm(LCSAdaptedGeneticAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LCSAdaptedGeneticAlgorithm(this, cloner);
+    }
+    public LCSAdaptedGeneticAlgorithm()
+      : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      #region Create parameters
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
+      #endregion
+
+      #region Create operators
+      VariableCreator variableCreator = new VariableCreator();
+      ResultsCollector resultsCollector1 = new ResultsCollector();
+      Placeholder analyzer1 = new Placeholder();
+      Placeholder selector = new Placeholder();
+      SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
+      ChildrenCreator childrenCreator = new ChildrenCreator();
+      UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      Placeholder crossover = new Placeholder();
+      DataReducer dataReducer = new DataReducer();
+      StochasticBranch stochasticBranch = new StochasticBranch();
+      Placeholder mutator = new Placeholder();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      SubScopesCounter subScopesCounter = new SubScopesCounter();
+      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
+      BestSelector bestSelector = new BestSelector();
+      RightReducer rightReducer = new RightReducer();
+      MergingReducer mergingReducer = new MergingReducer();
+      IntCounter intCounter = new IntCounter();
+      Comparator comparator = new Comparator();
+      Placeholder analyzer2 = new Placeholder();
+      ConditionalBranch conditionalBranch = new ConditionalBranch();
+
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class GeneticAlgorithm expects this to be called Generations
+
+      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector1.ResultsParameter.ActualName = "Results";
+
+      analyzer1.Name = "Analyzer";
+      analyzer1.OperatorParameter.ActualName = "Analyzer";
+
+      selector.Name = "Selector";
+      selector.OperatorParameter.ActualName = "Selector";
+
+      childrenCreator.ParentsPerChild = new IntValue(2);
+
+      crossover.Name = "Crossover";
+      crossover.OperatorParameter.ActualName = "Crossover";
+
+      dataReducer.Name = "Average Fitness of Parents";
+      dataReducer.ParameterToReduce.ActualName = "Fitness";
+      dataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Avg);
+      dataReducer.TargetParameter.ActualName = "Fitness";
+      dataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+
+      stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
+      stochasticBranch.RandomParameter.ActualName = "Random";
+
+      mutator.Name = "Mutator";
+      mutator.OperatorParameter.ActualName = "Mutator";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      subScopesCounter.Name = "Increment EvaluatedSolutions";
+      subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = "Maximization";
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "N";
+      bestSelector.QualityParameter.ActualName = "Fitness";
+
+      intCounter.Increment = new IntValue(1);
+      intCounter.ValueParameter.ActualName = "Generations";
+
+      comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      comparator.LeftSideParameter.ActualName = "Generations";
+      comparator.ResultParameter.ActualName = "Terminate";
+      comparator.RightSideParameter.ActualName = "MaximumGenerations";
+
+      analyzer2.Name = "Analyzer";
+      analyzer2.OperatorParameter.ActualName = "Analyzer";
+
+      conditionalBranch.ConditionParameter.ActualName = "Terminate";
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = variableCreator;
+      variableCreator.Successor = resultsCollector1;
+      resultsCollector1.Successor = analyzer1;
+      analyzer1.Successor = selector;
+      selector.Successor = subScopesProcessor1;
+      subScopesProcessor1.Operators.Add(new EmptyOperator());
+      subScopesProcessor1.Operators.Add(childrenCreator);
+      subScopesProcessor1.Successor = subScopesProcessor2;
+      childrenCreator.Successor = uniformSubScopesProcessor1;
+      uniformSubScopesProcessor1.Operator = crossover;
+      uniformSubScopesProcessor1.Successor = subScopesCounter;
+      crossover.Successor = dataReducer;
+      dataReducer.Successor = stochasticBranch;
+      stochasticBranch.FirstBranch = mutator;
+      stochasticBranch.SecondBranch = null;
+      stochasticBranch.Successor = subScopesRemover;
+      mutator.Successor = null;
+      subScopesRemover.Successor = null;
+      subScopesCounter.Successor = null;
+      subScopesProcessor2.Operators.Add(bestSelector);
+      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      subScopesProcessor2.Successor = mergingReducer;
+      bestSelector.Successor = rightReducer;
+      rightReducer.Successor = null;
+      mergingReducer.Successor = intCounter;
+      intCounter.Successor = comparator;
+      comparator.Successor = analyzer2;
+      analyzer2.Successor = conditionalBranch;
+      conditionalBranch.FalseBranch = selector;
+      conditionalBranch.TrueBranch = null;
+      conditionalBranch.Successor = null;
+      #endregion
+    }
+
+    public override IOperation Apply() {
+      if (CrossoverParameter.ActualValue == null)
+        return null;
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 9089)
@@ -24,8 +24,6 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39,13 +37,13 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+  public sealed class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     public string Filename { get; set; }
 
     #region Problem Properties
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
-    }
-    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
-      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      get { return typeof(IConditionActionProblem); }
+    }
+    public new IConditionActionProblem Problem {
+      get { return (IConditionActionProblem)base.Problem; }
       set { base.Problem = value; }
     }
@@ -59,19 +57,51 @@
       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
+    private ValueParameter<BoolValue> CreateInitialPopulationParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["CreateInitialPopulation"]; }
+    }
     private ValueParameter<IntValue> PopulationSizeParameter {
-      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
-    }
-    //for test purpose
-    public ValueParameter<ICombinedIntegerVectorCreator> SolutionCreatorParameter {
-      get { return (ValueParameter<ICombinedIntegerVectorCreator>)Parameters["SolutionCreator"]; }
-    }
-    public ValueParameter<IntValue> Length {
-      get { return (ValueParameter<IntValue>)Parameters["Length"]; }
-    }
-    public ValueParameter<IntValue> ActionPartLength {
-      get { return (ValueParameter<IntValue>)Parameters["ActionPartLength"]; }
-    }
-    public ValueParameter<IntMatrix> Bounds {
-      get { return (ValueParameter<IntMatrix>)Parameters["Bounds"]; }
+      get { return (ValueParameter<IntValue>)Parameters["N"]; }
+    }
+    private ValueParameter<PercentValue> BetaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Beta"]; }
+    }
+    private ValueParameter<PercentValue> AlphaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Alpha"]; }
+    }
+    private ValueParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    private ValueParameter<DoubleValue> PowerParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["v"]; }
+    }
+    private ValueParameter<PercentValue> GammaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Gamma"]; }
+    }
+    private ValueParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["CrossoverProbability"]; }
+    }
+    private ValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    private ValueParameter<IntValue> ThetaGAParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaGA"]; }
+    }
+    private ValueParameter<IntValue> ThetaDeletionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaDeletion"]; }
+    }
+    private ValueParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    private ValueParameter<PercentValue> DeltaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Delta"]; }
+    }
+    private ValueParameter<PercentValue> ExplorationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["ExplorationProbability"]; }
+    }
+    private ValueParameter<BoolValue> DoGASubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoGASubsumption"]; }
+    }
+    private ValueParameter<BoolValue> DoActionSetSubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoActionSetSubsumption"]; }
     }
     #endregion
@@ -86,9 +116,74 @@
       set { SetSeedRandomlyParameter.Value = value; }
     }
+    public BoolValue CreateInitialPopulation {
+      get { return CreateInitialPopulationParameter.Value; }
+      set { CreateInitialPopulationParameter.Value = value; }
+    }
     public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
     }
-
+    public PercentValue Beta {
+      get { return BetaParameter.Value; }
+      set { BetaParameter.Value = value; }
+    }
+    public PercentValue Alpha {
+      get { return AlphaParameter.Value; }
+      set { AlphaParameter.Value = value; }
+    }
+    public DoubleValue ErrorZero {
+      get { return ErrorZeroParameter.Value; }
+      set { ErrorZeroParameter.Value = value; }
+    }
+    public DoubleValue Power {
+      get { return PowerParameter.Value; }
+      set { PowerParameter.Value = value; }
+    }
+    public PercentValue Gamma {
+      get { return GammaParameter.Value; }
+      set { GammaParameter.Value = value; }
+    }
+    public PercentValue CrossoverProbability {
+      get { return CrossoverProbabilityParameter.Value; }
+      set { CrossoverProbabilityParameter.Value = value; }
+    }
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IntValue ThetaGA {
+      get { return ThetaGAParameter.Value; }
+      set { ThetaGAParameter.Value = value; }
+    }
+    public IntValue ThetaDeletion {
+      get { return ThetaDeletionParameter.Value; }
+      set { ThetaDeletionParameter.Value = value; }
+    }
+    public IntValue ThetaSubsumption {
+      get { return ThetaSubsumptionParameter.Value; }
+      set { ThetaSubsumptionParameter.Value = value; }
+    }
+    public PercentValue Delta {
+      get { return DeltaParameter.Value; }
+      set { DeltaParameter.Value = value; }
+    }
+    public PercentValue ExplorationProbability {
+      get { return ExplorationProbabilityParameter.Value; }
+      set { ExplorationProbabilityParameter.Value = value; }
+    }
+    public BoolValue DoGASubsumption {
+      get { return DoGASubsumptionParameter.Value; }
+      set { DoGASubsumptionParameter.Value = value; }
+    }
+    public BoolValue DoActionSetSubsumption {
+      get { return DoActionSetSubsumptionParameter.Value; }
+      set { DoActionSetSubsumptionParameter.Value = value; }
+    }
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    public LearningClassifierSystemMainLoop MainLoop {
+      get { return (LearningClassifierSystemMainLoop)RandomCreator.Successor; }
+    }
     #endregion
 
@@ -98,18 +193,25 @@
       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
-      //for test purpose
-      Parameters.Add(new ValueParameter<ICombinedIntegerVectorCreator>("SolutionCreator", "The operator to create a solution.", new UniformRandomCombinedIntegerVectorCreator()));
-      Parameters.Add(new ValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("ActionPartLength", "The operator to create a solution.", new IntValue(1)));
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueParameter<IntMatrix>("Bounds", "The operator to create a solution.", new IntMatrix(elements)));
+      Parameters.Add(new ValueParameter<BoolValue>("CreateInitialPopulation", "Specifies if a population should be created at the beginning of the algorithm.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>("N", "Max size of the population of solutions.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<PercentValue>("Beta", "Learning rate", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("Alpha", "", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("ErrorZero", "The error below which classifiers are considered to have equal accuracy", new DoubleValue(10)));
+      Parameters.Add(new ValueParameter<DoubleValue>("v", "Power parameter", new DoubleValue(5)));
+      Parameters.Add(new ValueParameter<PercentValue>("Gamma", "Discount factor", new PercentValue(0.71)));
+      Parameters.Add(new ValueParameter<PercentValue>("CrossoverProbability", "Probability of crossover", new PercentValue(0.9)));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "Probability of mutation", new PercentValue(0.05)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaGA", "GA threshold. GA is applied in a set when the average time since the last GA is greater than ThetaGA.", new IntValue(25)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaDeletion", "Deletion threshold. If the experience of a classifier is greater than ThetaDeletion, its fitness may be considered in its probability of deletion.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaSubsumption", "Subsumption threshold. The experience of a classifier must be greater than TheatSubsumption to be able to subsume another classifier.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<PercentValue>("Delta", "Delta specifies the fraction of mean fitness in [P] below which the fitness of a classifier may be considered in its probability of deletion", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("ExplorationProbability", "Probability of selecting the action uniform randomly", new PercentValue(0.5)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoGASubsumption", "Specifies if offsprings are tested for possible logical subsumption by parents.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoActionSetSubsumption", "Specifies if action set is tested for subsuming classifiers.", new BoolValue(true)));
       #endregion
 
       #region Create operators
       RandomCreator randomCreator = new RandomCreator();
-      SolutionsCreator solutionsCreator = new SolutionsCreator();
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+
       //ResultsCollector resultsCollector = new ResultsCollector();
       LearningClassifierSystemMainLoop mainLoop = new LearningClassifierSystemMainLoop();
@@ -120,30 +222,12 @@
       randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
       randomCreator.SetSeedRandomlyParameter.Value = null;
-
-      SolutionCreatorParameter.Value.ActionPartLengthParameter.ActualName = ActionPartLength.Name;
-      SolutionCreatorParameter.Value.LengthParameter.ActualName = Length.Name;
-      SolutionCreatorParameter.Value.BoundsParameter.ActualName = Bounds.Name;
-
-      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
-      solutionsCreator.SolutionCreatorParameter.ActualName = SolutionCreatorParameter.Name;
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = randomCreator;
-      randomCreator.Successor = solutionsCreator;
-      solutionsCreator.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
-      uniformSubScopeProcessor.Successor = mainLoop;
+      randomCreator.Successor = mainLoop;
       #endregion
     }
-    protected LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
+    private LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -153,4 +237,29 @@
     [StorableConstructor]
     private LearningClassifierSystem(bool deserializing) : base(deserializing) { }
+
+    protected override void OnProblemChanged() {
+      if (Problem != null) {
+        ParameterizeEvaluator(Problem.Evaluator);
+        MainLoop.SetCurrentProblem(Problem);
+      }
+      base.OnProblemChanged();
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator(Problem.Evaluator);
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+
+    private void ParameterizeEvaluator(IXCSEvaluator evaluator) {
+      evaluator.ActualTimeParameter.ActualName = "Iteration";
+      evaluator.BetaParameter.ActualName = BetaParameter.Name;
+      evaluator.AlphaParameter.ActualName = AlphaParameter.Name;
+      evaluator.PowerParameter.ActualName = PowerParameter.Name;
+      evaluator.ErrorZeroParameter.ActualName = ErrorZeroParameter.Name;
+    }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9089)
@@ -20,9 +20,8 @@
 #endregion
 
-using HeuristicLab.Algorithms.GeneticAlgorithm;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
@@ -31,5 +30,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 using HeuristicLab.Selection;
 
@@ -40,5 +38,5 @@
   [Item("LearningClassifierSystemMainLoop", "An operator which represents the main loop of a learning classifier system.")]
   [StorableClass]
-  public class LearningClassifierSystemMainLoop : AlgorithmOperator {
+  public sealed class LearningClassifierSystemMainLoop : AlgorithmOperator {
 
     #region Parameter Properties
@@ -54,22 +52,19 @@
     #endregion
 
-    #region Properties
-    public ISelector Selector {
-      get { return SelectorParameter.Value; }
-      set { SelectorParameter.Value = value; }
-    }
-    public ICrossover Crossover {
-      get { return CrossoverParameter.Value; }
-      set { CrossoverParameter.Value = value; }
-    }
-    public IManipulator Mutator {
-      get { return MutatorParameter.Value; }
-      set { MutatorParameter.Value = value; }
-    }
+    #region private properties
+    private SolutionsCreator initialSolutionsCreator;
+    private SolutionsCreator coveringMechanism;
+    private MatchConditionOperator matchConditionOperator;
+    private PredictionArrayCalculator predictionArrayCalculator;
+    private ActionSelector actionSelector;
+
+    private Placeholder evaluator;
+    private Placeholder actionExecuter;
+    private Placeholder classifierFetcher;
     #endregion
 
     [StorableConstructor]
     private LearningClassifierSystemMainLoop(bool deserializing) : base(deserializing) { }
-    protected LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
+    private LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -85,107 +80,162 @@
       #region Create parameters
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction.", new ItemSet<ISelector>() { new ProportionalSelector() }, new ProportionalSelector()));
-      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new SinglePointCrossover() }, new SinglePointCrossover()));
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, new UniformOnePositionManipulator()));
-      //for test purposes
-      int[] numbers = new int[3] { 1, 1, 1 };
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueLookupParameter<CombinedIntegerVector>("TestTarget", "Target for test", new CombinedIntegerVector(numbers, 1, elements)));
-
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover() }, new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover()));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      UniformOnePositionManipulator test = new UniformOnePositionManipulator();
+      test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
       #endregion
 
       #region Create operators
       VariableCreator variableCreator = new VariableCreator();
-      MatchSelector conditionMatchSelector = new MatchSelector();
-      MatchSelector actionMatchSelector = new MatchSelector();
+      ConditionalBranch initialPopulationConditionalBranch = new ConditionalBranch();
+      initialSolutionsCreator = new SolutionsCreator();
+      IntCounter iterationCounter = new IntCounter();
+      UniformSubScopesProcessor matchCondtionSubScopesProcessor = new UniformSubScopesProcessor();
+      matchConditionOperator = new MatchConditionOperator();
+      predictionArrayCalculator = new PredictionArrayCalculator();
+      actionSelector = new ActionSelector();
+      UniformSubScopesProcessor matchActionSubScopesProcessor = new UniformSubScopesProcessor();
+      MatchActionOperator matchActionOperator = new MatchActionOperator();
+      ConditionalSelector conditionMatchSelector = new ConditionalSelector();
+      ConditionalSelector actionMatchSelector = new ConditionalSelector();
       SubScopesProcessor coveringSubScopesProcessor = new SubScopesProcessor();
-      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      SubScopesCounter matchsetCounter = new SubScopesCounter();
       Comparator comparator = new Comparator();
-      ConditionalBranch conditionalBranch = new ConditionalBranch();
+      ConditionalBranch coveringConditionalBranch = new ConditionalBranch();
       MergingReducer mergingReducer = new MergingReducer();
-      SolutionsCreator coveringMechanism = new SolutionsCreator();
-      SubScopesProcessor actionSelectionSubScopesProcessor = new SubScopesProcessor();
-      MaxValueActionSelector maxValueActionSelection = new MaxValueActionSelector();
-      GeneticAlgorithmMainLoop geneticAlgorithmMainLoop = new GeneticAlgorithmMainLoop();
-
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+      MergingReducer mergingReducerWithSuccessor = new MergingReducer();
+      coveringMechanism = new SolutionsCreator();
+      evaluator = new Placeholder();
+      SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
+      DataReducer actionSetSizeDataReducer = new DataReducer();
+      UniformSubScopesProcessor accuracySubScopesProcessor = new UniformSubScopesProcessor();
+      CalculateAccuracy calculateAccuracy = new CalculateAccuracy();
+      SumAccuracy sumAccuracy = new SumAccuracy();
+      UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
+      LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
+
+      classifierFetcher = new Placeholder();
+      actionExecuter = new Placeholder();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("ZeroIntValue", new IntValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OneIntValue", new IntValue(1)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iteration", new IntValue(0)));
+
+      initialPopulationConditionalBranch.ConditionParameter.ActualName = "CreateInitialPopulation";
+
+      initialSolutionsCreator.NumberOfSolutionsParameter.ActualName = "N";
+
+      iterationCounter.ValueParameter.ActualName = "Iteration";
+      iterationCounter.IncrementParameter.ActualName = "OneIntValue";
+
+      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
+
+      matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
 
       conditionMatchSelector.CopySelected = new BoolValue(false);
-      conditionMatchSelector.MatchCondition = new BoolValue(true);
-      //this has to be set differently
-      conditionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      conditionMatchSelector.TargetMatchParameter.ActualName = "TestTarget";
+      conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";
+
+      matchsetCounter.Name = "Count number of rules in match set";
+      matchsetCounter.AccumulateParameter.Value = new BoolValue(false);
+      matchsetCounter.ValueParameter.ActualName = "MatchSetCount";
 
       comparator.Comparison = new Comparison(ComparisonType.LessOrEqual);
-      comparator.LeftSideParameter.ActualName = conditionMatchSelector.NumberOfSelectedSubScopesParameter.ActualName;
+      comparator.LeftSideParameter.ActualName = matchsetCounter.ValueParameter.ActualName;
       comparator.ResultParameter.ActualName = "Covering";
       //more than zero solutions have to be selected
       comparator.RightSideParameter.ActualName = "ZeroIntValue";
 
-      conditionalBranch.ConditionParameter.ActualName = "Covering";
-
-      subScopesRemover.SubScopeIndexParameter.ActualName = "OneIntValue";
-      subScopesRemover.RemoveAllSubScopes = false;
+      coveringConditionalBranch.Name = "Covering Branch";
+      coveringConditionalBranch.ConditionParameter.ActualName = "Covering";
+
+      matchActionSubScopesProcessor.Operator = matchActionOperator;
+
+      matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
+      matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
 
       coveringMechanism.NumberOfSolutionsParameter.ActualName = "OneIntValue";
-      coveringMechanism.SolutionCreatorParameter.ActualName = "SolutionCreator";
-
-      maxValueActionSelection.ValueParameter.ActualName = "Fitness";
-      maxValueActionSelection.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      actionSelector.PredictionArrayParameter.ActualName = predictionArrayCalculator.PredictionArrayParameter.Name;
+      actionSelector.RandomParameter.ActualName = "Random";
+      actionSelector.ExplorationProbabilityParameter.ActualName = "ExplorationProbability";
 
       actionMatchSelector.CopySelected = new BoolValue(false);
-      actionMatchSelector.MatchCondition = new BoolValue(false);
-      //this has to be set differently
-      actionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      actionMatchSelector.TargetMatchParameter.ActualName = maxValueActionSelection.SelectedActionParameter.ActualName;
+      actionMatchSelector.ConditionParameter.ActualName = "MatchAction";
 
       SelectorParameter.Value.CopySelected = new BoolValue(true);
       SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(200);
 
-      geneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
-      geneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      geneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
-      geneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
-      geneticAlgorithmMainLoop.ElitesParameter.ActualName = "OneIntValue";
-      geneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
-      geneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
+      evaluator.Name = "Evaluator";
+
+      classifierFetcher.Name = "ClassifierFetcher";
+
+      actionExecuter.Name = "ActionExecuter";
+
+      actionSetSizeDataReducer.TargetParameter.ActualName = "CurrentActionSetSize";
+      actionSetSizeDataReducer.ParameterToReduce.ActualName = "Numerosity";
+      actionSetSizeDataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      actionSetSizeDataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+
+      calculateAccuracy.AlphaParameter.ActualName = "Alpha";
+      calculateAccuracy.ErrorParameter.ActualName = "Error";
+      calculateAccuracy.ErrorZeroParameter.ActualName = "ErrorZero";
+      calculateAccuracy.PowerParameter.ActualName = "v";
+
+      sumAccuracy.AccuracyParameter.ActualName = calculateAccuracy.AccuracyParameter.ActualName;
+      sumAccuracy.NumerosityParameter.ActualName = "Numerosity";
+
+      adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
+      adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
+      adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
       //needed?
-      geneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
-      geneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = "Random";
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
-      //ParameterizeSelectors();
+      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
+      adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = conditionMatchSelector;
-      //variableCreator.Successor = geneticAlgorithmMainLoop;
-      //geneticAlgorithmMainLoop.Successor = conditionMatchSelector;
-      conditionMatchSelector.Successor = comparator;
-      comparator.Successor = conditionalBranch;
-      conditionalBranch.TrueBranch = coveringSubScopesProcessor;
-      conditionalBranch.FalseBranch = actionSelectionSubScopesProcessor;
-      conditionalBranch.Successor = subScopesRemover;
-      coveringMechanism.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
+
+      variableCreator.Successor = initialPopulationConditionalBranch;
+      initialPopulationConditionalBranch.TrueBranch = initialSolutionsCreator;
+      initialPopulationConditionalBranch.FalseBranch = new EmptyOperator();
+      initialPopulationConditionalBranch.Successor = classifierFetcher;
+      classifierFetcher.Successor = matchCondtionSubScopesProcessor;
+      matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
+      //variableCreator.Successor = adaptedGeneticAlgorithmMainLoop;
+      //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
+
+      conditionMatchSelector.Successor = coveringSubScopesProcessor;
       coveringSubScopesProcessor.Operators.Add(new EmptyOperator());
-      coveringSubScopesProcessor.Operators.Add(coveringMechanism);
-      coveringSubScopesProcessor.Successor = actionSelectionSubScopesProcessor;
-      actionSelectionSubScopesProcessor.Operators.Add(new EmptyOperator());
-      actionSelectionSubScopesProcessor.Operators.Add(maxValueActionSelection);
-      maxValueActionSelection.Successor = actionMatchSelector;
-      subScopesRemover.Successor = mergingReducer;
-      mergingReducer.Successor = conditionMatchSelector;
-      //mergingReducer.Successor = geneticAlgorithmMainLoop;
+      coveringSubScopesProcessor.Operators.Add(matchsetCounter);
+      coveringSubScopesProcessor.Successor = mergingReducerWithSuccessor;
+      matchsetCounter.Successor = comparator;
+      comparator.Successor = coveringConditionalBranch;
+      coveringConditionalBranch.TrueBranch = coveringMechanism;
+      coveringConditionalBranch.FalseBranch = new EmptyOperator();
+      coveringConditionalBranch.Successor = predictionArrayCalculator;
+      predictionArrayCalculator.Successor = actionSelector;
+      actionSelector.Successor = matchActionSubScopesProcessor;
+      matchActionSubScopesProcessor.Successor = actionMatchSelector;
+      actionMatchSelector.Successor = actionExecuter;
+      actionExecuter.Successor = actionSetSubScopesProcessor;
+      actionSetSubScopesProcessor.Operators.Add(new EmptyOperator());
+      actionSetSubScopesProcessor.Operators.Add(actionSetSizeDataReducer);
+      actionSetSizeDataReducer.Successor = accuracySubScopesProcessor;
+      accuracySubScopesProcessor.Operator = calculateAccuracy;
+      accuracySubScopesProcessor.Successor = sumAccuracy;
+      sumAccuracy.Successor = updateParametersSubScopesProcessor;
+      updateParametersSubScopesProcessor.Operator = evaluator;
+
+      actionSetSubScopesProcessor.Successor = mergingReducer;
+
+      mergingReducerWithSuccessor.Successor = iterationCounter;
+      iterationCounter.Successor = classifierFetcher;
+      //mergingReducer.Successor = adaptedGeneticAlgorithmMainLoop;
       #endregion
     }
@@ -197,4 +247,27 @@
         stochasticOp.RandomParameter.Hidden = true;
       }
+    }
+
+    internal void SetCurrentProblem(IConditionActionProblem problem) {
+      initialSolutionsCreator.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
+      initialSolutionsCreator.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      coveringMechanism.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
+      coveringMechanism.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      problem.ActionExecuter.SelectedActionParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
+
+      problem.ClassifierFetcher.IterationParameter.ActualName = "Iteration";
+
+      evaluator.OperatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
+
+      actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
+
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.Name;
+
+      predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
+      predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
     }
     //private void ParameterizeSelectors() {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9089)
@@ -25,4 +25,6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -31,8 +33,9 @@
   [StorableClass]
   [Item("CombinedIntegerVector", "Represents a combined vector of integer values.")]
-  public class CombinedIntegerVector : IntegerVector, IMatching {
+  public class CombinedIntegerVector : IntegerVector, IClassifier {
 
     [Storable]
-    protected int actionPart;
+    protected int actionLength;
+    public int ActionLength { get { return actionLength; } }
 
     /// <summary>
@@ -42,5 +45,6 @@
     /// </summary>
     [Storable]
-    protected int[,] bounds;
+    protected IntMatrix bounds;
+    public IntMatrix Bounds { get { return (IntMatrix)bounds.Clone(); } }
 
     [StorableConstructor]
@@ -48,24 +52,45 @@
     public CombinedIntegerVector() : base() { }
 
-    public CombinedIntegerVector(int[] elements, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(int[] elements, int actionPart, IntMatrix bounds)
       : base(elements) {
-      this.actionPart = actionPart;
+      this.actionLength = actionPart;
       //check if combinedVector satisfies bounds and if bounds is set correctly (at leats one row with 2 columns) is missing!
       this.bounds = bounds;
     }
 
-    public CombinedIntegerVector(IntegerVector combinedVector, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(IntegerVector combinedVector, int actionPart, IntMatrix bounds)
       : this(combinedVector.ToArray(), actionPart, bounds) { }
 
-    public CombinedIntegerVector(IntegerVector condition, IntegerVector action, int[,] bounds)
+    public CombinedIntegerVector(IntegerVector condition, IntegerVector action, IntMatrix bounds)
       : base(condition.Concat(action).ToArray()) {
-      actionPart = action.Length;
+      actionLength = action.Length;
       //check if combinedVector satisfies bounds and if bounds is set correctly (at leats one row with 2 columns) is missing!
       this.bounds = bounds;
     }
 
+    public CombinedIntegerVector(IntegerVector condition, IntMatrix conditionBounds, IntegerVector action, IntMatrix actionBounds)
+      : this(condition, action, CombineBounds(conditionBounds, actionBounds)) {
+    }
+
+    private static IntMatrix CombineBounds(IntMatrix conditionBounds, IntMatrix actionBounds) {
+      int columns = conditionBounds.Columns < actionBounds.Columns ? conditionBounds.Columns : actionBounds.Columns;
+      IntMatrix bounds = new IntMatrix(conditionBounds.Rows + actionBounds.Rows, columns);
+      for (int i = 0; i < conditionBounds.Rows; i++) {
+        for (int j = 0; j < columns; j++) {
+          bounds[i, j] = conditionBounds[i % conditionBounds.Rows, j];
+        }
+      }
+
+      for (int i = conditionBounds.Rows; i < actionBounds.Rows + conditionBounds.Rows; i++) {
+        for (int j = 0; j < columns; j++) {
+          bounds[i, j] = actionBounds[i % actionBounds.Rows, j];
+        }
+      }
+      return bounds;
+    }
+
     public CombinedIntegerVector(IRandom random, int length, int min, int max, int actionLenght, int actionMin, int actionMax) :
       this(new IntegerVector(length, random, min, max), new IntegerVector(actionLenght, random, actionMin, actionMax), null) {
-      bounds = new int[length + actionLenght, 2];
+      bounds = new IntMatrix(length + actionLenght, 2);
       for (int i = 0; i < length; i++) {
         bounds[i, 0] = min;
@@ -78,7 +103,7 @@
     }
 
-    public CombinedIntegerVector(int length, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(int length, int actionPart, IntMatrix bounds)
       : base(length) {
-      this.actionPart = actionPart;
+      this.actionLength = actionPart;
       this.bounds = bounds;
     }
@@ -86,28 +111,43 @@
     protected CombinedIntegerVector(CombinedIntegerVector original, Cloner cloner)
       : base(original, cloner) {
-      actionPart = original.actionPart;
-      bounds = (int[,])original.bounds.Clone();
-    }
+      actionLength = original.actionLength;
+      bounds = (IntMatrix)original.bounds.Clone();
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new CombinedIntegerVector(this, cloner);
     }
 
-    public IMatching Condition {
+    public IClassifier Condition {
       get {
-        int[] condition = new int[Length - actionPart];
-        Array.Copy(this.array, condition, Length - actionPart);
+        int[] condition = new int[Length - actionLength];
+        Array.Copy(this.array, condition, Length - actionLength);
         return new CombinedIntegerVector(condition, 0, bounds);
       }
     }
 
-    public IMatching Action {
+    public IClassifier Action {
       get {
-        int[] action = new int[actionPart];
-        Array.Copy(this.array, Length - actionPart, action, 0, actionPart);
-        return new CombinedIntegerVector(action, actionPart, bounds);
-      }
-    }
-
-    public bool MatchCondition(IMatching target) {
+        int[] action = new int[actionLength];
+        Array.Copy(this.array, Length - actionLength, action, 0, actionLength);
+
+        IntMatrix actionBounds = GetElementsOfBoundsForAction(bounds, Length, actionLength);
+        return new CombinedIntegerVector(action, actionLength, actionBounds);
+      }
+    }
+
+    private IntMatrix GetElementsOfBoundsForAction(IntMatrix bounds, int length, int actionPartLength) {
+      IntMatrix actionBounds = new IntMatrix(actionPartLength, bounds.Columns);
+      int start = length - actionPartLength;
+      for (int i = start; i < length; i++) {
+        int pos = i % bounds.Rows;
+        for (int j = 0; j < bounds.Columns; j++) {
+          actionBounds[i - start, j] = bounds[pos, j];
+        }
+      }
+      return actionBounds;
+    }
+
+    public bool MatchCondition(IClassifier target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
@@ -115,6 +155,6 @@
 
       int curbounds;
-      for (int i = 0; i < this.Length - this.actionPart; i++) {
-        curbounds = i % bounds.GetLength(0);
+      for (int i = 0; i < this.Length - this.actionLength; i++) {
+        curbounds = i % bounds.Rows;
         //if don't care symbol is matched, next indices can be checked
         if (this[i].Equals(bounds[curbounds, 1] - 1)) {
@@ -129,12 +169,12 @@
 
     // no "don't care" symbols have to be considered
-    public bool MatchAction(IMatching target) {
+    public bool MatchAction(IClassifier target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
-      if (targetVector.actionPart != this.actionPart) return false;
-
-      int curPos = this.Length - this.actionPart;
-      int curTargetPos = targetVector.Length - targetVector.actionPart;
-      for (int i = 0; i < this.actionPart; i++) {
+      if (targetVector.actionLength != this.actionLength) return false;
+
+      int curPos = this.Length - this.actionLength;
+      int curTargetPos = targetVector.Length - targetVector.actionLength;
+      for (int i = 0; i < this.actionLength; i++) {
         if (!this[curPos + i].Equals(targetVector[curTargetPos + i])) {
           return false;
@@ -149,6 +189,6 @@
       int curbounds;
       for (int i = 0; i < this.Length; i++) {
-        curbounds = i % bounds.GetLength(0);
-        if (i >= this.Length - this.actionPart || this[i] < bounds[curbounds, 1] - 1) {
+        curbounds = i % bounds.Rows;
+        if (i >= this.Length - this.actionLength || this[i] < bounds[curbounds, 1] - 1) {
           strBuilder.Append(this[i]);
         } else {
@@ -171,10 +211,10 @@
     }
 
-    public bool Equals(IMatching other) {
+    public bool Equals(IClassifier other) {
       return this.MatchAction(other) && this.MatchCondition(other);
     }
 
     public override int GetHashCode() {
-      int result = actionPart;
+      int result = actionLength;
       for (int i = 0; i < array.Length; i++) {
         result ^= array[i];
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCreator.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCreator.cs	(revision 9089)
@@ -23,5 +23,6 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33,5 +34,18 @@
   [Item("CombinedIntegerVectorCreator", "A base class for operators creating combined int-valued vectors.")]
   [StorableClass]
-  public abstract class CombinedIntegerVectorCreator : IntegerVectorCreator, ICombinedIntegerVectorCreator {
+  public abstract class CombinedIntegerVectorCreator : SingleSuccessorOperator, IStochasticOperator, ICombinedIntegerVectorCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
     public IValueLookupParameter<IntValue> ActionPartLengthParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["ActionPartLength"]; }
@@ -44,14 +58,17 @@
     [StorableConstructor]
     protected CombinedIntegerVectorCreator(bool deserializing) : base(deserializing) { }
-    protected CombinedIntegerVectorCreator(IntegerVectorCreator original, Cloner cloner) : base(original, cloner) { }
+    protected CombinedIntegerVectorCreator(CombinedIntegerVectorCreator original, Cloner cloner) : base(original, cloner) { }
     protected CombinedIntegerVectorCreator()
       : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
       Parameters.Add(new LookupParameter<CombinedIntegerVector>("CombinedIntegerVector", "The vector which should be manipulated."));
       Parameters.Add(new ValueLookupParameter<IntValue>("ActionPartLength", "The length of the vector."));
     }
 
-    protected override IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds) {
-      CombinedIntegerVectorParameter.ActualValue = Create(random, length, bounds, ActionPartLengthParameter.ActualValue);
-      return CombinedIntegerVectorParameter.ActualValue;
+    public sealed override IOperation Apply() {
+      CombinedIntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue, ActionPartLengthParameter.ActualValue);
+      return base.Apply();
     }
 
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCrossover.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCrossover.cs	(revision 9089)
@@ -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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  /// <summary>
+  /// A base class for operators that perform a crossover of combined int-valued vectors.
+  /// </summary>
+  [Item("CombinedIntegerVectorCrossover", "A base class for operators that perform a crossover of combined int-valued vectors.")]
+  [StorableClass]
+  public abstract class CombinedIntegerVectorCrossover : SingleSuccessorOperator, IIntegerVectorOperator, ICombinedIntegerVectorCrossover, ICombinedIntegerVectorOperator, ICrossover, IStochasticOperator, IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<CombinedIntegerVector>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<CombinedIntegerVector>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<CombinedIntegerVector> ChildParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
+    }
+
+    [StorableConstructor]
+    protected CombinedIntegerVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected CombinedIntegerVectorCrossover(CombinedIntegerVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    protected CombinedIntegerVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new ScopeTreeLookupParameter<CombinedIntegerVector>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "CombinedIntegerVector";
+      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "CombinedIntegerVector";
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract CombinedIntegerVector Cross(IRandom random, ItemArray<CombinedIntegerVector> parents);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9089)
@@ -0,0 +1,65 @@
+﻿#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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  [Item("CombinedIntegerVectorManipulator", "Base class for combined integer vector manipulators.")]
+  [StorableClass]
+  public abstract class CombinedIntegerVectorManipulator : SingleSuccessorOperator, ICombinedIntegerVectorManipulator, IStochasticOperator {
+
+    #region parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<CombinedIntegerVector> ChildParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
+    }
+    public ILookupParameter<CombinedIntegerVector> ParentParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CombinedIntegerVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected CombinedIntegerVectorManipulator(CombinedIntegerVectorManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CombinedIntegerVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Child"));
+      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Parent"));
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, ChildParameter.ActualValue, ParentParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9089)
@@ -0,0 +1,76 @@
+﻿#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.Encodings.ConditionActionEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding.Covering {
+  [Item("CombinedIntegerVectorCoveringCreator", "Description missing")]
+  [StorableClass]
+  public class CombinedIntegerVectorCoveringCreator : SingleSuccessorOperator, ICoveringSolutionCreator {
+
+    #region Parameter Properties
+    public ILookupParameter<IClassifier> CoverClassifierParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
+    }
+    public ILookupParameter<IClassifier> ActionParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["Action"]; }
+    }
+    public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
+    }
+    public IValueLookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CombinedIntegerVectorCoveringCreator(bool deserializing) : base(deserializing) { }
+    protected CombinedIntegerVectorCoveringCreator(CombinedIntegerVectorCoveringCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CombinedIntegerVectorCoveringCreator(this, cloner);
+    }
+    public CombinedIntegerVectorCoveringCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
+      Parameters.Add(new LookupParameter<IClassifier>("Action"));
+      Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("ChangeSymbolProbability"));
+    }
+
+    public override IOperation Apply() {
+      CombinedIntegerVector condition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition;
+      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
+
+      //TODO: manipulation
+
+      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(condition, condition.Bounds, action, action.Bounds);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Creators/UniformRandomCombinedIntegerVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Creators/UniformRandomCombinedIntegerVectorCreator.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Creators/UniformRandomCombinedIntegerVectorCreator.cs	(revision 9089)
@@ -50,17 +50,7 @@
     /// <returns>The newly created integer vector.</returns>
     public static CombinedIntegerVector Apply(IRandom random, int length, IntMatrix bounds, int actionPartLength) {
-      var result = new CombinedIntegerVector(length, actionPartLength, GetElementsOfBounds(bounds));
+      var result = new CombinedIntegerVector(length, actionPartLength, bounds);
       result.Randomize(random, bounds);
       return result;
-    }
-
-    private static int[,] GetElementsOfBounds(IntMatrix bounds) {
-      int[,] realBounds = new int[bounds.Rows, bounds.Columns];
-      for (int i = 0; i < bounds.Rows; i++) {
-        for (int j = 0; j < bounds.Columns; j++) {
-          realBounds[i, j] = bounds[i, j];
-        }
-      }
-      return realBounds;
     }
 
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 9089)
@@ -0,0 +1,45 @@
+﻿#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.CombinedIntegerVectorEncoding {
+  [Item("SinglePointCrossover", "Single point crossover for integer vectors. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
+  [StorableClass]
+  public class SinglePointCrossover : CombinedIntegerVectorCrossover {
+    [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);
+    }
+
+    protected override CombinedIntegerVector Cross(IRandom random, ItemArray<CombinedIntegerVector> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return new CombinedIntegerVector(HeuristicLab.Encodings.IntegerVectorEncoding.SinglePointCrossover.Apply(random, parents[0], parents[1]), parents[0].ActionLength, parents[0].Bounds);
+    }
+  }
+}
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 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9089)
@@ -104,16 +104,32 @@
     <Compile Include="CombinedIntegerVector.cs" />
     <Compile Include="CombinedIntegerVectorCreator.cs" />
+    <Compile Include="CombinedIntegerVectorCrossover.cs" />
+    <Compile Include="CombinedIntegerVectorManipulator.cs" />
+    <Compile Include="Covering\CombinedIntegerVectorCoveringCreator.cs" />
     <Compile Include="Creators\UniformRandomCombinedIntegerVectorCreator.cs" />
-    <Compile Include="Matching\IMatching.cs" />
+    <Compile Include="Crossovers\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\ICombinedIntegerVectorManipulator.cs" />
+    <Compile Include="Interfaces\ICombinedIntegerVectorCrossover.cs" />
     <Compile Include="Interfaces\IBoundedCombinedIntegerVectorOperator.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorCreator.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorOperator.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Manipulator\UniformActionManipulator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionsManipulator.cs" />
     <Compile Include="Plugin.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <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>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/IBoundedCombinedIntegerVectorOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/IBoundedCombinedIntegerVectorOperator.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/IBoundedCombinedIntegerVectorOperator.cs	(revision 9089)
@@ -20,5 +20,8 @@
 #endregion
 
-using HeuristicLab.Encodings.IntegerVectorEncoding;
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
@@ -26,4 +29,6 @@
   /// The bounds parameter must contain at least one row and at least two columns. The first two columns specify min and max values, the last column specifies the step size, but is optional (1 is assumed if omitted).
   /// </summary>
-  public interface IBoundedCombinedIntegerVectorOperator : IBoundedIntegerVectorOperator { }
+  public interface IBoundedCombinedIntegerVectorOperator : ICombinedIntegerVectorOperator, IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    IValueLookupParameter<IntMatrix> BoundsParameter { get; }
+  }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCreator.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCreator.cs	(revision 9089)
@@ -20,10 +20,13 @@
 #endregion
 
+using System;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public interface ICombinedIntegerVectorCreator : IIntegerVectorCreator, IBoundedCombinedIntegerVectorOperator {
+  public interface ICombinedIntegerVectorCreator : ISolutionCreator, IBoundedCombinedIntegerVectorOperator, ICombinedIntegerVectorOperator, IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    IValueLookupParameter<IntValue> LengthParameter { get; }
     IValueLookupParameter<IntValue> ActionPartLengthParameter { get; }
     ILookupParameter<CombinedIntegerVector> CombinedIntegerVectorParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCrossover.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCrossover.cs	(revision 9089)
@@ -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.Optimization;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator for crossing vectors of int-valued data.
+  /// </summary>
+  public interface ICombinedIntegerVectorCrossover : ICrossover, ICombinedIntegerVectorOperator {
+    ILookupParameter<ItemArray<CombinedIntegerVector>> ParentsParameter { get; }
+    ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9089)
@@ -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.Optimization;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator for crossing vectors of int-valued data.
+  /// </summary>
+  public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
+    ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
+    ILookupParameter<CombinedIntegerVector> ParentParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorOperator.cs	(revision 9088)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorOperator.cs	(revision 9089)
@@ -20,7 +20,10 @@
 #endregion
 
+using System;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public interface ICombinedIntegerVectorOperator : IOperator { }
+  public interface ICombinedIntegerVectorOperator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+  }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs	(revision 9089)
@@ -0,0 +1,60 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  public class UniformActionManipulator : CombinedIntegerVectorManipulator {
+
+    public ILookupParameter<IItemSet<CombinedIntegerVector>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<CombinedIntegerVector>>)Parameters["PossibleActions"]; }
+    }
+
+    [StorableConstructor]
+    protected UniformActionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformActionManipulator(UniformActionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformActionManipulator(this, cloner);
+    }
+    public UniformActionManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IItemSet<CombinedIntegerVector>>("PossibleActions"));
+    }
+
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, CombinedIntegerVector parent) {
+      return Manipulate(random, parent, child, PossibleActionsParameter.ActualValue);
+    }
+
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, IEnumerable<CombinedIntegerVector> possibleActions) {
+      var otherActions = possibleActions.Except(((CombinedIntegerVector)parent.Action).ToEnumerable());
+      int actionIndex = random.Next(otherActions.Count());
+      CombinedIntegerVector newAction = otherActions.ElementAt(actionIndex);
+      return new CombinedIntegerVector((CombinedIntegerVector)child.Condition, newAction, child.Bounds);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9089)
@@ -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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  [Item("UniformOnePositionManipulator", "")]
+  [StorableClass]
+  public class UniformOnePositionInConditionManipulator : CombinedIntegerVectorManipulator {
+
+    [StorableConstructor]
+    protected UniformOnePositionInConditionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformOnePositionInConditionManipulator(UniformOnePositionInConditionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformOnePositionInConditionManipulator(this, cloner);
+    }
+    public UniformOnePositionInConditionManipulator()
+      : base() {
+    }
+
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
+      return Manipulate(parent, child, random.Next(((CombinedIntegerVector)child.Condition).Length));
+    }
+
+    public static CombinedIntegerVector Manipulate(CombinedIntegerVector parent, CombinedIntegerVector child, int index) {
+      int max = child.Bounds[index % child.Bounds.Rows, 1];
+      if (child[index].Equals(max)) {
+        child[index] = parent[index];
+      } else {
+        child[index] = max;
+      }
+      return child;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionsManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionsManipulator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionsManipulator.cs	(revision 9089)
@@ -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.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding.Manipulator {
+  public class UniformSomePositionsManipulator : CombinedIntegerVectorManipulator {
+
+    public IValueLookupParameter<PercentValue> ProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["Probability"]; }
+    }
+    public ILookupParameter<IItemSet<CombinedIntegerVector>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<CombinedIntegerVector>>)Parameters["PossibleActions"]; }
+    }
+
+    [StorableConstructor]
+    protected UniformSomePositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformSomePositionsManipulator(UniformSomePositionsManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSomePositionsManipulator(this, cloner);
+    }
+    public UniformSomePositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<PercentValue>("Probability", "The probability for each dimension to be manipulated.", new PercentValue(0.5)));
+      Parameters.Add(new LookupParameter<IItemSet<CombinedIntegerVector>>("PossibleActions"));
+    }
+
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
+      return Manipulate(random, parent, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    }
+
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+      for (int index = 0; index < child.Length - child.ActionLength; index++) {
+        if (random.NextDouble() < probability) {
+          UniformOnePositionInConditionManipulator.Manipulate(parent, child, index);
+        }
+      }
+
+      if (child.ActionLength > 0 && random.NextDouble() < probability) {
+        UniformActionManipulator.Manipulate(random, parent, child, possibleActions);
+      }
+      return child;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs	(revision 9089)
@@ -0,0 +1,79 @@
+﻿#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.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("ActionSelector", "")]
+  [StorableClass]
+  public class ActionSelector : SingleSuccessorOperator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IClassifier> SelectedActionParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    }
+    public ILookupParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
+      get { return (ILookupParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
+    }
+    public ILookupParameter<PercentValue> ExplorationProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["ExplorationProbability"]; }
+    }
+
+    [StorableConstructor]
+    protected ActionSelector(bool deserializing) : base(deserializing) { }
+    protected ActionSelector(ActionSelector original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ActionSelector()
+      : 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 LookupParameter<PercentValue>("ExplorationProbability"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ActionSelector(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (RandomParameter.ActualValue.NextDouble() > ExplorationProbabilityParameter.ActualValue.Value) {
+        double maxValue = PredictionArrayParameter.ActualValue.Max(x => x.Value.Value);
+        SelectedActionParameter.ActualValue = PredictionArrayParameter.ActualValue.Where(x => x.Value.Value.IsAlmost(maxValue))
+                                                                                  .Select(x => x.Key)
+                                                                                  .First();
+      } else {
+        int actionIndex = RandomParameter.ActualValue.Next(0, PredictionArrayParameter.ActualValue.Count);
+        SelectedActionParameter.ActualValue = PredictionArrayParameter.ActualValue.ElementAt(actionIndex).Key;
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs	(revision 9089)
@@ -0,0 +1,63 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("MaxValueActionSelector", "")]
+  [StorableClass]
+  public class MaxValueActionSelector : OldActionSelector {
+
+    public ILookupParameter<ItemArray<DoubleValue>> ValueParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ValueParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected MaxValueActionSelector(bool deserializing) : base(deserializing) { }
+    protected MaxValueActionSelector(MaxValueActionSelector original, Cloner cloner) : base(original, cloner) { }
+    public MaxValueActionSelector()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ValueParameter", "DoubleValue which will be summed up."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MaxValueActionSelector(this, cloner);
+    }
+
+    protected override IClassifier SelectAction(List<IScope> scopes) {
+      Dictionary<IClassifier, double> actionSet = new Dictionary<IClassifier, double>();
+      for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
+        var action = MatchParameter.ActualValue[i].Action;
+        if (actionSet.ContainsKey(action)) {
+          actionSet[action] += ValueParameter.ActualValue[i].Value;
+        } else {
+          actionSet[action] = ValueParameter.ActualValue[i].Value;
+        }
+      }
+      return actionSet.OrderByDescending(x => x.Value).First().Key;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs	(revision 9089)
@@ -0,0 +1,67 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("OldActionSelector", "A base class for action selection operators.")]
+  [StorableClass]
+  public abstract class OldActionSelector : SingleSuccessorOperator {
+
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
+    }
+    public IValueLookupParameter<IClassifier> SelectedActionParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    }
+
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+
+    [StorableConstructor]
+    protected OldActionSelector(bool deserializing) : base(deserializing) { }
+    protected OldActionSelector(OldActionSelector original, Cloner cloner) : base(original, cloner) { }
+
+    protected OldActionSelector()
+      : base() {
+      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."));
+    }
+
+    public sealed override IOperation Apply() {
+      List<IScope> scopes = new List<IScope>(CurrentScope.SubScopes);
+      SelectedActionParameter.ActualValue = SelectAction(scopes);
+      return base.Apply();
+    }
+
+    protected abstract IClassifier 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 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs	(revision 9089)
@@ -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.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("RandomActionSelector", "A random action selector.")]
+  [StorableClass]
+  public class RandomActionSelector : OldActionSelector {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    protected RandomActionSelector(bool deserializing) : base(deserializing) { }
+    protected RandomActionSelector(RandomActionSelector original, Cloner cloner) : base(original, cloner) { }
+    public RandomActionSelector()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator used for stochastic selection."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomActionSelector(this, cloner);
+    }
+
+    protected override IClassifier SelectAction(List<IScope> scopes) {
+      IRandom random = RandomParameter.ActualValue;
+      int index = random.Next(MatchParameter.ActualValue.Length);
+      return MatchParameter.ActualValue[index].Action;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9089)
@@ -0,0 +1,130 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("CoveringOperator", "")]
+  [StorableClass]
+  public class CoveringOperator : SingleSuccessorOperator, ICovering {
+
+    #region Parameter Properties
+    public ILookupParameter<IClassifier> CoverClassifierParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
+    }
+    public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
+      get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
+    }
+    public ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    }
+    public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MinimalNumberOfUniqueActions"]; }
+    }
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters[" Evaluator"]; }
+    }
+    public IValueLookupParameter<ICoveringSolutionCreator> SolutionCreatorParameter {
+      get { return (IValueLookupParameter<ICoveringSolutionCreator>)Parameters["SolutionCreator"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<BoolValue> ParallelParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Parallel"]; }
+    }
+    private ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CoveringOperator(bool deserializing) : base(deserializing) { }
+    protected CoveringOperator(CoveringOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CoveringOperator(this, cloner);
+    }
+    public CoveringOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("ActionsInMatchSet"));
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("PossibleActions"));
+      Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
+      Parameters.Add(new ValueLookupParameter<ICoveringSolutionCreator>("SolutionCreator"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operator should be applied in parallel on all sub-scopes, otherwise false.", new BoolValue(true)));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new solutions are added as sub-scopes."));
+    }
+
+    public override IOperation Apply() {
+      int count = MinimalNumberOfUniqueActionsParameter.ActualValue.Value - ActionsInMatchSetParameter.ActualValue.Count;
+      ICoveringSolutionCreator creator = SolutionCreatorParameter.ActualValue;
+      IOperator evaluator = EvaluatorParameter.ActualValue;
+      bool parallel = ParallelParameter.ActualValue.Value;
+
+      IItemSet<IClassifier> clone = (IItemSet<IClassifier>)PossibleActionsParameter.ActualValue.Clone();
+      clone.ExceptWith(ActionsInMatchSetParameter.ActualValue);
+
+      if (count > clone.Count) {
+        throw new ArgumentException("More classifiers with unique actions shall be created than unique actions are available.");
+      }
+
+      int current = CurrentScope.SubScopes.Count;
+      for (int i = 0; i < count; i++) {
+        CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
+      }
+
+      creator.ActionParameter.ActualName = "Action";
+      OperationCollection variableCreation = new OperationCollection() { Parallel = parallel };
+      OperationCollection creation = new OperationCollection();
+      OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
+      for (int i = 0; i < count; i++) {
+        VariableCreator variableCreator = new VariableCreator();
+        int pos = RandomParameter.ActualValue.Next(clone.Count);
+        IClassifier action = clone.ElementAt(pos);
+        clone.Remove(action);
+        variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
+        variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
+        creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
+        evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
+      }
+      OperationCollection next = new OperationCollection();
+      next.Add(variableCreation);
+      next.Add(creation);
+      next.Add(evaluation);
+      next.Add(base.Apply());
+      return next;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9089)
@@ -0,0 +1,37 @@
+﻿#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.ConditionActionEncoding {
+  public interface ICovering : IStochasticOperator {
+    ILookupParameter<IClassifier> CoverClassifierParameter { get; }
+    ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
+    ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }
+
+    ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter { get; }
+    IValueLookupParameter<IOperator> EvaluatorParameter { get; }
+    IValueLookupParameter<ICoveringSolutionCreator> SolutionCreatorParameter { get; }
+    IValueLookupParameter<BoolValue> ParallelParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9089)
@@ -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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    ILookupParameter<IClassifier> CoverClassifierParameter { get; }
+    ILookupParameter<IClassifier> ActionParameter { get; }
+
+    IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IConditionActionEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IConditionActionEvaluator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IConditionActionEvaluator.cs	(revision 9089)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IClassifierFitnessEvaluator : IEvaluator {
+    IValueLookupParameter<DoubleValue> FitnessParameter { get; }
+    IValueLookupParameter<DoubleValue> CurrentPayoffParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IXCSEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IXCSEvaluator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/IXCSEvaluator.cs	(revision 9089)
@@ -0,0 +1,49 @@
+﻿#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;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IXCSEvaluator : IClassifierFitnessEvaluator {
+    IValueLookupParameter<DoubleValue> PredictionParameter { get; }
+    IValueLookupParameter<DoubleValue> ErrorParameter { get; }
+    IValueLookupParameter<IntValue> ExperienceParameter { get; }
+    IValueLookupParameter<IntValue> TimestampParameter { get; }
+    IValueLookupParameter<DoubleValue> AverageActionSetSizeParameter { get; }
+    ILookupParameter<DoubleValue> AccuracyParameter { get; }
+    ILookupParameter<DoubleValue> AccuracySumParameter { get; }
+    //used for macroclassifiers
+    IValueLookupParameter<IntValue> NumerosityParameter { get; }
+
+    //inital parameters
+    ILookupParameter<DoubleValue> InitialPredictionParameter { get; }
+    ILookupParameter<DoubleValue> InitialErrorParameter { get; }
+    ILookupParameter<DoubleValue> InitialFitnessParameter { get; }
+
+    ILookupParameter<PercentValue> AlphaParameter { get; }
+    ILookupParameter<PercentValue> BetaParameter { get; }
+    ILookupParameter<DoubleValue> PowerParameter { get; }
+    ILookupParameter<DoubleValue> ErrorZeroParameter { get; }
+    ILookupParameter<IntValue> ActualTimeParameter { get; }
+    ILookupParameter<IntValue> CurrentActionSetSizeParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs	(revision 9089)
@@ -0,0 +1,196 @@
+﻿#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;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("XCSEvaluator", "Evaluator tries to match condition and action of IMatching.")]
+  [StorableClass]
+  public class XCSEvaluator : SingleSuccessorOperator, IXCSEvaluator {
+    #region parameter properties
+    public IValueLookupParameter<DoubleValue> FitnessParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Fitness"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CurrentPayoffParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentPayoff"]; }
+    }
+    public IValueLookupParameter<DoubleValue> PredictionParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Prediction"]; }
+    }
+    public IValueLookupParameter<DoubleValue> ErrorParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Error"]; }
+    }
+    public IValueLookupParameter<IntValue> ExperienceParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Experience"]; }
+    }
+    public IValueLookupParameter<IntValue> TimestampParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Timestamp"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AverageActionSetSizeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AverageActionSetSize"]; }
+    }
+    public IValueLookupParameter<IntValue> NumerosityParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Numerosity"]; }
+    }
+    public ILookupParameter<DoubleValue> InitialPredictionParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InitialPrediction"]; }
+    }
+    public ILookupParameter<DoubleValue> InitialErrorParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InitialError"]; }
+    }
+    public ILookupParameter<DoubleValue> InitialFitnessParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["InitialFitness"]; }
+    }
+    public ILookupParameter<PercentValue> BetaParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["Beta"]; }
+    }
+    public ILookupParameter<PercentValue> AlphaParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["Alpha"]; }
+    }
+    public ILookupParameter<DoubleValue> PowerParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["v"]; }
+    }
+    public ILookupParameter<IntValue> ActualTimeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ActualTime"]; }
+    }
+    public ILookupParameter<IntValue> CurrentActionSetSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentActionSetSize"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    public ILookupParameter<DoubleValue> AccuracyParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Accuracy"]; }
+    }
+    public ILookupParameter<DoubleValue> AccuracySumParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["AccuracySum"]; }
+    }
+    #endregion
+
+    #region properties
+    private int Experience {
+      get { return ExperienceParameter.ActualValue.Value; }
+      set { ExperienceParameter.ActualValue.Value = value; }
+    }
+    private double Beta {
+      get { return BetaParameter.ActualValue.Value; }
+      set { BetaParameter.ActualValue.Value = value; }
+    }
+    private double Prediction {
+      get { return PredictionParameter.ActualValue.Value; }
+      set { PredictionParameter.ActualValue.Value = value; }
+    }
+    private double CurrentPayoff {
+      get { return CurrentPayoffParameter.ActualValue.Value; }
+      set { CurrentPayoffParameter.ActualValue.Value = value; }
+    }
+    private double Error {
+      get { return ErrorParameter.ActualValue.Value; }
+      set { ErrorParameter.ActualValue.Value = value; }
+    }
+    private double AverageActionSetSize {
+      get { return AverageActionSetSizeParameter.ActualValue.Value; }
+      set { AverageActionSetSizeParameter.ActualValue.Value = value; }
+    }
+    private int CurrentActionSetSize {
+      get { return CurrentActionSetSizeParameter.ActualValue.Value; }
+      set { CurrentActionSetSizeParameter.ActualValue.Value = value; }
+    }
+    private double Fitness {
+      get { return FitnessParameter.ActualValue.Value; }
+      set { FitnessParameter.ActualValue.Value = value; }
+    }
+    private double Accuracy {
+      get { return AccuracyParameter.ActualValue.Value; }
+    }
+    private double AccuracySum {
+      get { return AccuracySumParameter.ActualValue.Value; }
+    }
+    private int Numerosity {
+      get { return NumerosityParameter.ActualValue.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected XCSEvaluator(bool deserializing) : base(deserializing) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new XCSEvaluator(this, cloner);
+    }
+    protected XCSEvaluator(XCSEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public XCSEvaluator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Fitness", ""));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentPayoff", ""));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Prediction", ""));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Error", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Experience", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Timestamp", ""));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageActionSetSize", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("Accuracy", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("AccuracySum", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Numerosity", ""));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("InitialPrediction"));
+      Parameters.Add(new LookupParameter<DoubleValue>("InitialError"));
+      Parameters.Add(new LookupParameter<DoubleValue>("InitialFitness"));
+      Parameters.Add(new LookupParameter<IntValue>("ActualTime"));
+      Parameters.Add(new LookupParameter<PercentValue>("Beta"));
+      Parameters.Add(new LookupParameter<PercentValue>("Alpha"));
+      Parameters.Add(new LookupParameter<DoubleValue>("v"));
+      Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentActionSetSize"));
+    }
+
+    public override IOperation Apply() {
+      if (PredictionParameter.ActualValue == null) {
+        //the classifier has just been created
+        PredictionParameter.ActualValue = new DoubleValue(InitialPredictionParameter.ActualValue.Value);
+        ErrorParameter.ActualValue = new DoubleValue(InitialErrorParameter.ActualValue.Value);
+        FitnessParameter.ActualValue = new DoubleValue(InitialFitnessParameter.ActualValue.Value);
+        ExperienceParameter.ActualValue = new IntValue(0);
+        TimestampParameter.ActualValue = new IntValue(ActualTimeParameter.ActualValue.Value);
+        AverageActionSetSizeParameter.ActualValue = new DoubleValue(1);
+        NumerosityParameter.ActualValue = new IntValue(1);
+      } else {
+        Experience += 1;
+        if (Experience < (1 / Beta)) {
+          Prediction += (CurrentPayoff - Prediction) / Experience;
+          Error += (Math.Abs(CurrentPayoff - Prediction) - Error) / Experience;
+          AverageActionSetSize += (CurrentActionSetSize - AverageActionSetSize) / Experience;
+        } else {
+          Prediction += Beta * (CurrentPayoff - Prediction);
+          Error += Beta * (Math.Abs(CurrentPayoff - Prediction) - Error);
+          AverageActionSetSize += Beta * (CurrentActionSetSize - AverageActionSetSize);
+        }
+        Fitness += Beta * ((Accuracy * Numerosity) / AccuracySum - Fitness);
+      }
+      return base.Apply();
+    }
+  }
+}
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 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9089)
@@ -0,0 +1,121 @@
+﻿<?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>{422FB262-0845-4969-8D16-12F057AA90B1}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.ConditionActionEncoding</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.ConditionActionEncoding-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, 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.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>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-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="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Selection-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <Private>False</Private>
+    </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="ActionSelection\ActionSelector.cs" />
+    <Compile Include="ActionSelection\OldActionSelector.cs" />
+    <Compile Include="ActionSelection\MaxValueActionSelector.cs" />
+    <Compile Include="ActionSelection\RandomActionSelector.cs" />
+    <Compile Include="Covering\CoveringOperator.cs" />
+    <Compile Include="Covering\ICovering.cs" />
+    <Compile Include="Covering\ICoveringSolutionCreator.cs" />
+    <Compile Include="Evaluators\XCSEvaluator.cs" />
+    <Compile Include="Evaluators\IConditionActionEvaluator.cs" />
+    <Compile Include="Evaluators\IXCSEvaluator.cs" />
+    <Compile Include="IClassifier.cs" />
+    <Compile Include="Interfaces\IConditionActionProblem.cs" />
+    <Compile Include="Interfaces\IConditionActionProblemData.cs" />
+    <Compile Include="Operator\CalculateAccuracy.cs" />
+    <Compile Include="Operator\CountNumberOfUniqueActions.cs" />
+    <Compile Include="Operator\PredictionArrayCalculator.cs" />
+    <Compile Include="Operator\MatchActionOperator.cs" />
+    <Compile Include="Operator\MatchConditionOperator.cs" />
+    <Compile Include="Operator\SumAccuracy.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Reinforcement\ActionExecuter.cs" />
+    <Compile Include="Reinforcement\IActionExecuter.cs" />
+    <Compile Include="Reinforcement\IClassifierFetcher.cs" />
+    <Compile Include="Selectors\IMatchSelector.cs" />
+    <Compile Include="Selectors\MatchSelector.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+  </ItemGroup>
+  <ItemGroup />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.ConditionActionEncoding/3.3/IClassifier.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9089)
@@ -0,0 +1,43 @@
+﻿#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.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);
+
+    //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();
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9089)
@@ -0,0 +1,39 @@
+﻿#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.ConditionActionEncoding {
+  public interface IConditionActionProblem : IHeuristicOptimizationProblem {
+    IParameter ProblemDataParameter { get; }
+    IConditionActionProblemData ProblemData { get; }
+    IParameter ActionExecuterParameter { get; }
+    IActionExecuter ActionExecuter { get; }
+    IParameter ClassifierFetcherParameter { get; }
+    IClassifierFetcher ClassifierFetcher { get; }
+
+    IParameter PossibleActionsParameter { get; }
+    IItemSet<IClassifier> PossibleActions { get; }
+
+    new IXCSEvaluator Evaluator { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs	(revision 9089)
@@ -0,0 +1,35 @@
+﻿#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.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IConditionActionProblemData : INamedItem {
+    Dataset Dataset { get; }
+    ICheckedItemList<StringValue> ConditionVariables { get; }
+    ICheckedItemList<StringValue> ActionVariables { get; }
+    IEnumerable<string> AllowedConditionVariables { get; }
+    IEnumerable<string> AllowedActionVariables { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CalculateAccuracy.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CalculateAccuracy.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CalculateAccuracy.cs	(revision 9089)
@@ -0,0 +1,89 @@
+﻿#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;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("CalculateAccuracy", "")]
+  [StorableClass]
+  public class CalculateAccuracy : SingleSuccessorOperator {
+    public ILookupParameter<PercentValue> AlphaParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["Alpha"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Error"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    public ILookupParameter<DoubleValue> PowerParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["v"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AccuracyParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Accuracy"]; }
+    }
+
+    private double Error {
+      get { return ErrorParameter.ActualValue.Value; }
+    }
+    private double ErrorZero {
+      get { return ErrorZeroParameter.ActualValue.Value; }
+    }
+    private double Alpha {
+      get { return AlphaParameter.ActualValue.Value; }
+    }
+    private double Power {
+      get { return PowerParameter.ActualValue.Value; }
+    }
+
+    [StorableConstructor]
+    protected CalculateAccuracy(bool deserializing) : base(deserializing) { }
+    protected CalculateAccuracy(CalculateAccuracy original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CalculateAccuracy()
+      : base() {
+      Parameters.Add(new LookupParameter<PercentValue>("Alpha"));
+      Parameters.Add(new LookupParameter<DoubleValue>("Error"));
+      Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
+      Parameters.Add(new LookupParameter<DoubleValue>("v"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Accuracy"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CalculateAccuracy(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (Error < ErrorZero) {
+        AccuracyParameter.ActualValue = new DoubleValue(1);
+      } else {
+        AccuracyParameter.ActualValue = new DoubleValue(Alpha * Math.Pow(Error / ErrorZero, -Power));
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9089)
@@ -0,0 +1,62 @@
+﻿#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.ConditionActionEncoding {
+  [Item("CountNumberOfUniqueActions", "")]
+  [StorableClass]
+  public class CountNumberOfUniqueActions : SingleSuccessorOperator {
+
+    public ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
+    }
+    public IValueLookupParameter<IItemSet<IClassifier>> UniqueActionsParameter {
+      get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
+    }
+
+    [StorableConstructor]
+    protected CountNumberOfUniqueActions(bool deserializing) : base(deserializing) { }
+    protected CountNumberOfUniqueActions(CountNumberOfUniqueActions original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CountNumberOfUniqueActions(this, cloner);
+    }
+    public CountNumberOfUniqueActions()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
+      Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
+    }
+    public override IOperation Apply() {
+      ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
+      foreach (var classifier in ClassifiersParameter.ActualValue) {
+        actions.Add(classifier.Action);
+      }
+      UniqueActionsParameter.Value = actions;
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs	(revision 9089)
@@ -0,0 +1,65 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("MatchActionOperator", "")]
+  [StorableClass]
+  public class MatchActionOperator : SingleSuccessorOperator {
+    protected ILookupParameter<BoolValue> MatchActionParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MatchAction"]; }
+    }
+    public ILookupParameter<IClassifier> TargetMatchParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
+    }
+    public ILookupParameter<IClassifier> MatchParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["MatchParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected MatchActionOperator(bool deserializing) : base(deserializing) { }
+    protected MatchActionOperator(MatchActionOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MatchActionOperator()
+      : 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<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MatchActionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IClassifier target = TargetMatchParameter.ActualValue;
+      IClassifier match = MatchParameter.ActualValue;
+      MatchActionParameter.ActualValue = new BoolValue(match.MatchAction(target));
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9089)
@@ -0,0 +1,65 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("MatchConditionOperator", "")]
+  [StorableClass]
+  public class MatchConditionOperator : SingleSuccessorOperator {
+    protected ILookupParameter<BoolValue> MatchConditionParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
+    }
+    public ILookupParameter<IClassifier> TargetMatchParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
+    }
+    public ILookupParameter<IClassifier> MatchParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["MatchParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected MatchConditionOperator(bool deserializing) : base(deserializing) { }
+    protected MatchConditionOperator(MatchConditionOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MatchConditionOperator()
+      : 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<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MatchConditionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IClassifier target = TargetMatchParameter.ActualValue;
+      IClassifier match = MatchParameter.ActualValue;
+      MatchConditionParameter.ActualValue = new BoolValue(match.MatchCondition(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 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs	(revision 9089)
@@ -0,0 +1,92 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("PredictionArrayCalculator", "")]
+  [StorableClass]
+  public class PredictionArrayCalculator : SingleSuccessorOperator {
+
+    public ILookupParameter<ItemArray<DoubleValue>> FitnessParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Fitness"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> PredictionParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Prediction"]; }
+    }
+    public IValueParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
+      get { return (IValueParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
+    }
+    public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected PredictionArrayCalculator(bool deserializing) : base(deserializing) { }
+    protected PredictionArrayCalculator(PredictionArrayCalculator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PredictionArrayCalculator()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitness"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Prediction"));
+      Parameters.Add(new ValueLookupParameter<IItemDictionary<IClassifier, 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."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PredictionArrayCalculator(this, cloner);
+    }
+
+    public sealed override IOperation Apply() {
+      IItemDictionary<IClassifier, DoubleValue> predictionArray = new ItemDictionary<IClassifier, DoubleValue>();
+      IDictionary<IClassifier, double> fitnessSumPerAction = new Dictionary<IClassifier, double>();
+      ItemArray<DoubleValue> fitnesses = FitnessParameter.ActualValue;
+      ItemArray<DoubleValue> predictions = PredictionParameter.ActualValue;
+      for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
+        var action = MatchParameter.ActualValue[i].Action;
+        if (predictionArray.ContainsKey(action)) {
+          predictionArray[action].Value += predictions[i].Value * fitnesses[i].Value;
+          fitnessSumPerAction[action] += fitnesses[i].Value;
+        } else {
+          predictionArray[action] = new DoubleValue(predictions[i].Value * fitnesses[i].Value);
+          fitnessSumPerAction[action] = fitnesses[i].Value;
+        }
+      }
+
+      foreach (var action in predictionArray.Keys) {
+        if (fitnessSumPerAction[action] != 0) {
+          predictionArray[action].Value /= fitnessSumPerAction[action];
+        }
+      }
+
+      PredictionArrayParameter.ActualValue = predictionArray;
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SumAccuracy.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SumAccuracy.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SumAccuracy.cs	(revision 9089)
@@ -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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("SumAccuracy", "")]
+  [StorableClass]
+  public class SumAccuracy : SingleSuccessorOperator {
+    public ILookupParameter<ItemArray<DoubleValue>> AccuracyParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Accuracy"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerosityParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosity"]; }
+    }
+    protected IValueLookupParameter<DoubleValue> AccuracySumParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AccuracySum"]; }
+    }
+
+    [StorableConstructor]
+    protected SumAccuracy(bool deserializing) : base(deserializing) { }
+    protected SumAccuracy(SumAccuracy original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SumAccuracy()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Accuracy"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosity"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AccuracySum"));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SumAccuracy(this, cloner);
+    }
+
+    public sealed override IOperation Apply() {
+      ItemArray<DoubleValue> accuracies = AccuracyParameter.ActualValue;
+      ItemArray<IntValue> numerosities = NumerosityParameter.ActualValue;
+      double accuracySum = 0.0;
+      for (int i = 0; i < accuracies.Length; i++) {
+        accuracySum += accuracies[i].Value * numerosities[i].Value;
+      }
+      AccuracySumParameter.ActualValue = new DoubleValue(accuracySum);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Plugin.cs.frame	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Plugin.cs.frame	(revision 9089)
@@ -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.ConditionActionEncoding {
+  [Plugin("HeuristicLab.Encodings.ConditionActionEncoding", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Encodings.ConditionActionEncoding-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  public class HeuristicLabEncodingsConditionActionEncodingPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Properties/AssemblyInfo.cs.frame	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Properties/AssemblyInfo.cs.frame	(revision 9089)
@@ -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.ConditionActionEncoding-3.3")]
+[assembly: AssemblyDescription("A general implementation of encodings with condition and action part.")]
+[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("66e09f77-028d-4bea-94ff-e6a224aa4aac")]
+
+// 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.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs	(revision 9089)
@@ -0,0 +1,79 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("ActionExecuter", "")]
+  [StorableClass]
+  public class ActionExecuter : SingleSuccessorOperator, IActionExecuter {
+
+    #region parameter
+    public IValueLookupParameter<IClassifier> SelectedActionParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
+    }
+    public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CurrentPayoffParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentPayoff"]; }
+    }
+    public ILookupParameter<DoubleValue> NegativeRewardParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["NegativeReward"]; }
+    }
+    public ILookupParameter<DoubleValue> PositiveRewardParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["PositiveReward"]; }
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ActionExecuter(this, cloner);
+    }
+    protected ActionExecuter(ActionExecuter original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    [StorableConstructor]
+    protected ActionExecuter(bool deserializing) : base(deserializing) { }
+
+    public ActionExecuter()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction"));
+      Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentPayoff"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("NegativeReward"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("PositiveReward"));
+    }
+
+    public override IOperation Apply() {
+      if (SelectedActionParameter.ActualValue.Action.Equals(CurrentClassifierToMatchParameter.ActualValue.Action)) {
+        CurrentPayoffParameter.ActualValue = PositiveRewardParameter.ActualValue;
+      } else {
+        CurrentPayoffParameter.ActualValue = NegativeRewardParameter.ActualValue;
+      }
+      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 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs	(revision 9089)
@@ -0,0 +1,35 @@
+﻿#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 IActionExecuter : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    IValueLookupParameter<IClassifier> SelectedActionParameter { get; }
+    IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
+    IValueLookupParameter<DoubleValue> CurrentPayoffParameter { get; }
+    ILookupParameter<DoubleValue> NegativeRewardParameter { get; }
+    ILookupParameter<DoubleValue> PositiveRewardParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs	(revision 9089)
@@ -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 System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IClassifierFetcher : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
+    ILookupParameter<IConditionActionProblemData> ProblemDataParameter { get; }
+    ILookupParameter<IntValue> IterationParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/IMatchSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/IMatchSelector.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/IMatchSelector.cs	(revision 9089)
@@ -0,0 +1,35 @@
+﻿#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: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/MatchSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/MatchSelector.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Selectors/MatchSelector.cs	(revision 9089)
@@ -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 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.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9089)
@@ -0,0 +1,103 @@
+﻿<?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>{EA51D441-F6A3-41E1-9993-A2488E93C222}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.ConditionActionClassification</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.ConditionActionClassification-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.Core-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-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.Encodings.IntegerVectorEncoding-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <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="HeuristicLab.Problems.DataAnalysis-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <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="Implementation\ConditionActionClassificationProblem.cs" />
+    <Compile Include="Implementation\ConditionActionClassificationProblemData.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Reinforcement\CombinedIntegerVectorClassifierFetcher.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Plugin.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
+      <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
+      <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-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>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9089)
@@ -0,0 +1,236 @@
+﻿#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.Data;
+using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.ConditionActionClassification {
+  [StorableClass]
+  public class ConditionActionClassificationProblem : HeuristicOptimizationProblem<XCSEvaluator, UniformRandomCombinedIntegerVectorCreator>, IConditionActionProblem {
+    private const string ClassifierFetcherParameterName = "ClassifierFetcher";
+    private const string ActionExecuterParameterName = "ActionExecuter";
+
+    IXCSEvaluator IConditionActionProblem.Evaluator {
+      get { return Evaluator; }
+    }
+
+    #region parameter properties
+    public IValueParameter<ConditionActionClassificationProblemData> ProblemDataParameter {
+      get { return (IValueParameter<ConditionActionClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+    public IFixedValueParameter<DoubleValue> PositiveRewardParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["PositiveReward"]; }
+    }
+    public IFixedValueParameter<DoubleValue> NegativeRewardParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["NegativeReward"]; }
+    }
+    public IFixedValueParameter<DoubleValue> InitialPredictionParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialPrediction"]; }
+    }
+    public IFixedValueParameter<DoubleValue> InitialErrorParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialError"]; }
+    }
+    public IFixedValueParameter<DoubleValue> InitialFitnessParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialFitness"]; }
+    }
+    public IFixedValueParameter<IItemSet<IClassifier>> PossibleActionsParameter {
+      get { return (IFixedValueParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    }
+    private IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
+    }
+    //for test purposes
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IFixedValueParameter<IntValue> ActionPartLengthParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ActionPartLength"]; }
+    }
+    public IFixedValueParameter<IntMatrix> BoundsParameter {
+      get { return (IFixedValueParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+    #endregion
+
+    #region properties
+    IParameter IConditionActionProblem.ProblemDataParameter {
+      get { return ProblemDataParameter; }
+    }
+    IConditionActionProblemData IConditionActionProblem.ProblemData {
+      get { return ProblemData; }
+    }
+    public ConditionActionClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.Value; }
+    }
+    IParameter IConditionActionProblem.PossibleActionsParameter {
+      get { return PossibleActionsParameter; }
+    }
+    IItemSet<IClassifier> IConditionActionProblem.PossibleActions {
+      get { return PossibleActions; }
+    }
+    public IItemSet<IClassifier> PossibleActions {
+      get { return PossibleActionsParameter.Value; }
+    }
+    public IActionExecuter ActionExecuter {
+      get { return ActionExecuterParameter.Value; }
+    }
+    public ValueParameter<IActionExecuter> ActionExecuterParameter {
+      get { return (ValueParameter<IActionExecuter>)Parameters[ActionExecuterParameterName]; }
+    }
+    IParameter IConditionActionProblem.ActionExecuterParameter { get { return ActionExecuterParameter; } }
+    public CombinedIntegerVectorClassifierFetcher ClassifierFetcher {
+      get { return ClassifierFetcherParameter.Value; }
+    }
+    public ValueParameter<CombinedIntegerVectorClassifierFetcher> ClassifierFetcherParameter {
+      get { return (ValueParameter<CombinedIntegerVectorClassifierFetcher>)Parameters[ClassifierFetcherParameterName]; }
+    }
+    IClassifierFetcher IConditionActionProblem.ClassifierFetcher { get { return ClassifierFetcher; } }
+    IParameter IConditionActionProblem.ClassifierFetcherParameter { get { return ClassifierFetcherParameter; } }
+
+    private IntValue ThetaMinimalNumberOfActions {
+      get { return ThetaMinimalNumberOfActionsParameter.Value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ConditionActionClassificationProblem(bool deserializing) : base(deserializing) { }
+    protected ConditionActionClassificationProblem(ConditionActionClassificationProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConditionActionClassificationProblem(this, cloner);
+    }
+
+    public ConditionActionClassificationProblem() :
+      this(new ConditionActionClassificationProblemData(new Dataset(ConditionActionClassificationProblemData.defaultVariableNames, ConditionActionClassificationProblemData.defaultData),
+        ConditionActionClassificationProblemData.defaultVariableNames.Take(ConditionActionClassificationProblemData.defaultVariableNames.Length - 1), ConditionActionClassificationProblemData.defaultVariableNames.Last().ToEnumerable()),
+        new XCSEvaluator(), new UniformRandomCombinedIntegerVectorCreator()) {
+    }
+
+    public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator)
+      : base(evaluator, solutionCreator) {
+      Parameters.Add(new FixedValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(7)));
+      Parameters.Add(new FixedValueParameter<IntValue>("ActionPartLength", "The operator to create a solution.", new IntValue(1)));
+      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 3 }, { 0, 2 } };
+      Parameters.Add(new FixedValueParameter<IntMatrix>("Bounds", "The operator to create a solution.", new IntMatrix(elements)));
+      Parameters.Add(new ValueParameter<ConditionActionClassificationProblemData>("ProblemData", "", problemData));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("PositiveReward", "", new DoubleValue(1000)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("NegativeReward", "", new DoubleValue(0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("InitialPrediction", "Initial Presiction", new DoubleValue(0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("InitialError", "Initial Error", new DoubleValue(0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("InitialFitness", "Initial Fitness", new DoubleValue(0)));
+
+      Parameters.Add(new ValueParameter<IActionExecuter>(ActionExecuterParameterName, "", new ActionExecuter()));
+      Parameters.Add(new ValueParameter<CombinedIntegerVectorClassifierFetcher>(ClassifierFetcherParameterName, "", new CombinedIntegerVectorClassifierFetcher()));
+      Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
+      Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure."));
+
+      Evaluator.InitialErrorParameter.ActualName = "InitialError";
+      Evaluator.InitialFitnessParameter.ActualName = "InitialFitness";
+      Evaluator.InitialPredictionParameter.ActualName = "InitialPrediction";
+
+      SolutionCreator.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;
+      SolutionCreator.LengthParameter.ActualName = LengthParameter.Name;
+      SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+
+      ClassifierFetcher.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;
+      ClassifierFetcher.BoundsParameter.ActualName = BoundsParameter.Name;
+      ClassifierFetcher.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+
+      ActionExecuter.CurrentClassifierToMatchParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      ActionExecuter.NegativeRewardParameter.ActualName = NegativeRewardParameter.Name;
+      ActionExecuter.PositiveRewardParameter.ActualName = PositiveRewardParameter.Name;
+
+      SetPossibleActions();
+      ThetaMinimalNumberOfActions.Value = PossibleActions.Count;
+
+      BoundsParameter.ValueChanged += new System.EventHandler(BoundsParameter_ValueChanged);
+      LengthParameter.ValueChanged += new System.EventHandler(LengthParameter_ValueChanged);
+      ActionPartLengthParameter.ValueChanged += new System.EventHandler(ActionPartLengthParameter_ValueChanged);
+    }
+
+    #region event handler
+    private void ActionPartLengthParameter_ValueChanged(object sender, System.EventArgs e) {
+      SetPossibleActions();
+    }
+    private void LengthParameter_ValueChanged(object sender, System.EventArgs e) {
+      SetPossibleActions();
+    }
+    private void BoundsParameter_ValueChanged(object sender, System.EventArgs e) {
+      SetPossibleActions();
+    }
+    #endregion
+
+    private void SetPossibleActions() {
+      //get bounds of action
+      IntMatrix actionBounds = GetElementsOfBoundsForAction(BoundsParameter.Value, LengthParameter.Value.Value, ActionPartLengthParameter.Value.Value);
+      int actionLength = ActionPartLengthParameter.Value.Value;
+      int start = LengthParameter.Value.Value - actionLength;
+      int[] elements = new int[actionLength];
+      int[] curPos = new int[actionLength];
+      bool done = false;
+      //initialize curPos
+      for (int i = 0; i < actionBounds.Rows; i++) {
+        curPos[i] = actionBounds[i, 0];
+      }
+      PossibleActions.Clear();
+      while (!done) {
+        PossibleActions.Add(new CombinedIntegerVector(curPos, actionLength, actionBounds));
+        curPos = GetNextAction(curPos, actionBounds, out done);
+      }
+
+    }
+
+    private int[] GetNextAction(int[] curPos, IntMatrix actionBounds, out bool done) {
+      int cur = 0;
+      while (cur < curPos.Length) {
+        curPos[cur] += actionBounds.Columns < 3 ? 1 : actionBounds[cur, 2];
+        if (curPos[cur] >= actionBounds[cur, 1]) {
+          curPos[cur] = actionBounds[cur, 0];
+          cur++;
+        } else {
+          break;
+        }
+      }
+      done = cur >= curPos.Length;
+      return curPos;
+    }
+
+    private IntMatrix GetElementsOfBoundsForAction(IntMatrix bounds, int length, int actionPartLength) {
+      IntMatrix actionBounds = new IntMatrix(actionPartLength, bounds.Columns);
+      int start = length - actionPartLength;
+      for (int i = start; i < length; i++) {
+        int pos = i % bounds.Rows;
+        for (int j = 0; j < bounds.Columns; j++) {
+          actionBounds[i - start, j] = bounds[pos, j];
+        }
+      }
+      return actionBounds;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblemData.cs	(revision 9089)
@@ -0,0 +1,111 @@
+﻿#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.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.ConditionActionClassification {
+  public class ConditionActionClassificationProblemData : ParameterizedNamedItem, IConditionActionProblemData {
+
+    #region default data
+    public static string[] defaultVariableNames = new string[] { "a", "b", "c", "d", "e", "f", "g" };
+    public static double[,] defaultData = new double[,]{
+      {0,0,1,1,0,0,0},
+      {0,1,1,1,0,0,0},
+      {0,0,1,0,0,0,0},
+      {1,0,1,0,1,1,0}
+    };
+    #endregion
+
+    #region parameter properites
+    public IFixedValueParameter<Dataset> DatasetParameter {
+      get { return (IFixedValueParameter<Dataset>)Parameters["Dataset"]; }
+    }
+    public IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>> ConditionVariablesParameter {
+      get { return (IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>>)Parameters["ConditionVariables"]; }
+    }
+    public IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>> ActionVariablesParameter {
+      get { return (IFixedValueParameter<ReadOnlyCheckedItemList<StringValue>>)Parameters["ActionVariables"]; }
+    }
+    #endregion
+
+    public Dataset Dataset {
+      get { return DatasetParameter.Value; }
+    }
+
+    public ICheckedItemList<StringValue> ConditionVariables {
+      get { return ConditionVariablesParameter.Value; }
+    }
+
+    public ICheckedItemList<StringValue> ActionVariables {
+      get { return ActionVariablesParameter.Value; }
+    }
+
+    public IEnumerable<string> AllowedConditionVariables {
+      get { return ConditionVariables.CheckedItems.Select(x => x.Value.Value); }
+    }
+    public IEnumerable<string> AllowedActionVariables {
+      get { return ActionVariables.CheckedItems.Select(x => x.Value.Value); }
+    }
+
+
+    [StorableConstructor]
+    protected ConditionActionClassificationProblemData(bool deserializing) : base(deserializing) { }
+    protected ConditionActionClassificationProblemData(ConditionActionClassificationProblemData original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConditionActionClassificationProblemData(this, cloner);
+    }
+
+    public ConditionActionClassificationProblemData(Dataset dataset, IEnumerable<string> allowedConditionVariables, IEnumerable<string> allowedActionVariables) {
+      if (dataset == null) throw new ArgumentNullException("The dataset must not be null.");
+      if (allowedActionVariables == null) throw new ArgumentNullException("The allowedActionVariables must not be null.");
+      if (allowedConditionVariables == null) throw new ArgumentNullException("The allowedActionVariables must not be null.");
+
+      if (allowedActionVariables.Except(dataset.DoubleVariables).Any())
+        throw new ArgumentException("All allowed action variables must be present in the dataset and of type double.");
+      if (allowedConditionVariables.Except(dataset.DoubleVariables).Any())
+        throw new ArgumentException("All allowed condition variables must be present in the dataset and of type double.");
+
+      var actionVariables = new CheckedItemList<StringValue>(dataset.DoubleVariables.Select(x => new StringValue(x)));
+      var conditionVariables = new CheckedItemList<StringValue>(actionVariables);
+      foreach (StringValue x in actionVariables) {
+        actionVariables.SetItemCheckedState(x, allowedActionVariables.Contains(x.Value));
+        conditionVariables.SetItemCheckedState(x, allowedConditionVariables.Contains(x.Value));
+      }
+
+      Parameters.Add(new FixedValueParameter<Dataset>("Dataset", "", dataset));
+      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ActionVariables", "", actionVariables.AsReadOnly()));
+      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ConditionVariables", "", conditionVariables.AsReadOnly()));
+
+      ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Plugin.cs.frame	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Plugin.cs.frame	(revision 9089)
@@ -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.Problems.ConditionActionClassification {
+  [Plugin("HeuristicLab.Problems.ConditionActionClassification", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.ConditionActionClassification-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  public class HeuristicLabProblemsConditionActionClassificationPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Properties/AssemblyInfo.cs.frame	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Properties/AssemblyInfo.cs.frame	(revision 9089)
@@ -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.Problems.ConditionActionClassification-3.3")]
+[assembly: AssemblyDescription("Problems which can handle the condition action encoding.")]
+[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("45e0e5b7-01c9-4bcd-aeea-c975d4405d20")]
+
+// 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.Problems.ConditionActionClassification/3.3/Reinforcement/CombinedIntegerVectorClassifierFetcher.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Reinforcement/CombinedIntegerVectorClassifierFetcher.cs	(revision 9089)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Reinforcement/CombinedIntegerVectorClassifierFetcher.cs	(revision 9089)
@@ -0,0 +1,82 @@
+﻿#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.Encodings.CombinedIntegerVectorEncoding;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.ConditionActionClassification {
+  [Item("CombinedIntegerVectorClassifierFetcher", "")]
+  [StorableClass]
+  public class CombinedIntegerVectorClassifierFetcher : SingleSuccessorOperator, IClassifierFetcher {
+    #region parameters
+    public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
+    }
+    public ILookupParameter<IConditionActionProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IConditionActionProblemData>)Parameters["ProblemData"]; }
+    }
+    public ILookupParameter<IntValue> ActionPartLengthParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ActionPartLength"]; }
+    }
+    public ILookupParameter<IntMatrix> BoundsParameter {
+      get { return (ILookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+    public ILookupParameter<IntValue> IterationParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Iteration"]; }
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CombinedIntegerVectorClassifierFetcher(this, cloner);
+    }
+    protected CombinedIntegerVectorClassifierFetcher(CombinedIntegerVectorClassifierFetcher original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    [StorableConstructor]
+    protected CombinedIntegerVectorClassifierFetcher(bool deserializing) : base(deserializing) { }
+    public CombinedIntegerVectorClassifierFetcher()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
+      Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData"));
+      Parameters.Add(new LookupParameter<IntValue>("ActionPartLength"));
+      Parameters.Add(new LookupParameter<IntMatrix>("Bounds"));
+      Parameters.Add(new LookupParameter<IntValue>("Iteration"));
+    }
+
+    public override IOperation Apply() {
+      Dataset dataset = ProblemDataParameter.ActualValue.Dataset;
+      int row = IterationParameter.ActualValue.Value % dataset.Rows;
+      int[] elements = new int[dataset.Columns];
+      for (int i = 0; i < dataset.Columns; i++) {
+        elements[i] = int.Parse(dataset.GetValue(row, i));
+      }
+      CurrentClassifierToMatchParameter.ActualValue = new CombinedIntegerVector(elements, ActionPartLengthParameter.ActualValue.Value, BoundsParameter.ActualValue);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/LearningClassifierSystem.sln
===================================================================
--- /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9088)
+++ /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9089)
@@ -11,4 +11,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.LearningClassifierSystems-3.3", "HeuristicLab.Algorithms.LearningClassifierSystems\3.3\HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj", "{1FAB379A-3624-4EE3-9756-E8CA34BAADB4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.ConditionActionEncoding-3.3", "HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj", "{422FB262-0845-4969-8D16-12F057AA90B1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.ConditionActionClassification-3.3", "HeuristicLab.Problems.ConditionActionClassification\3.3\HeuristicLab.Problems.ConditionActionClassification-3.3.csproj", "{EA51D441-F6A3-41E1-9993-A2488E93C222}"
 EndProject
 Global
@@ -42,4 +46,20 @@
 		{1FAB379A-3624-4EE3-9756-E8CA34BAADB4}.Release|x64.ActiveCfg = Release|Any CPU
 		{1FAB379A-3624-4EE3-9756-E8CA34BAADB4}.Release|x86.ActiveCfg = Release|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Release|Any CPU.Build.0 = Release|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Release|x64.ActiveCfg = Release|Any CPU
+		{422FB262-0845-4969-8D16-12F057AA90B1}.Release|x86.ActiveCfg = Release|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Release|x64.ActiveCfg = Release|Any CPU
+		{EA51D441-F6A3-41E1-9993-A2488E93C222}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
