Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Discretizer/UniformWidthDiscretizer.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Discretizer/UniformWidthDiscretizer.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Discretizer/UniformWidthDiscretizer.cs	(revision 9334)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  [StorableClass]
+  [Item("UniformWidthDiscretizer", "")]
+  public class UniformWidthDiscretizer : Item, IDiscretizer {
+
+    [Storable]
+    private int bins;
+
+    [Storable]
+    private IDictionary<string, IList<double>> variableMicroItervals;
+
+    [StorableConstructor]
+    protected UniformWidthDiscretizer(bool deserializing) : base(deserializing) { }
+    protected UniformWidthDiscretizer(UniformWidthDiscretizer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformWidthDiscretizer()
+      : base() {
+      bins = 5;
+    }
+    public UniformWidthDiscretizer(int bins)
+      : base() {
+      variableMicroItervals = new Dictionary<string, IList<double>>();
+      this.bins = bins;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformWidthDiscretizer(this, cloner);
+    }
+
+    public int NumberOfMicroIntervals(string attribute) {
+      return bins;
+    }
+
+    public IEnumerable<double> discretizeValues(string attribute, IEnumerable<double> values) {
+      if (variableMicroItervals.ContainsKey(attribute)) {
+        throw new ArgumentException("Values of attribute " + attribute + " are already set.");
+      }
+
+      double min = values.Min();
+      double max = values.Max();
+
+      double intervalWidth = (max - min) / bins;
+      List<double> cutPoints = new List<double>(bins - 1);
+      double val = min;
+      for (int i = 0; i < bins - 1; i++) {
+        val += intervalWidth;
+        cutPoints.Add(val);
+      }
+
+      variableMicroItervals[attribute] = cutPoints;
+
+      return cutPoints;
+    }
+
+    public IEnumerable<double> GetCutPoints(string attribute) {
+      return variableMicroItervals[attribute];
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssist.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssist.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssist.cs	(revision 9334)
@@ -0,0 +1,506 @@
+#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.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  /// <summary>
+  /// A genetic algorithm.
+  /// </summary>
+  [Item("GAssist", "A learning classifier system.")]
+  [Creatable("Algorithms")]
+  [StorableClass]
+  public sealed class GAssist : 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; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
+    #region Parameter Properties
+    private ValueParameter<IntValue> SeedParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private ValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+    private ValueParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    public IConstrainedValueParameter<ISelector> SelectorParameter {
+      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
+    }
+    private ValueParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["CrossoverProbability"]; }
+    }
+    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
+      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
+    }
+    private ValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {
+      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
+    private ValueParameter<IntValue> ElitesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["Elites"]; }
+    }
+    private ValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (ValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private ValueParameter<GAssistSpecialStageMultiOperator> SpecialStagesParameter {
+      get { return (ValueParameter<GAssistSpecialStageMultiOperator>)Parameters["SpecialStages"]; }
+    }
+    private ValueParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    }
+    private ValueParameter<PercentValue> StartReinitializeProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["StartReinitializeProbability"]; }
+    }
+    private ValueParameter<PercentValue> EndReinitializeProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["EndReinitializeProbability"]; }
+    }
+    public IConstrainedValueParameter<IDiscreteDoubleValueModifier> ReinitializeCurveOperatorParameter {
+      get { return (IConstrainedValueParameter<IDiscreteDoubleValueModifier>)Parameters["ReinitializeCurveOperator"]; }
+    }
+    private ValueParameter<PercentValue> SplitProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["SplitProbability"]; }
+    }
+    private ValueParameter<PercentValue> MergeProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["MergeProbability"]; }
+    }
+    private ValueParameter<PercentValue> OneProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["OneProbability"]; }
+    }
+    private ValueParameter<IntValue> MaximumNumberOfIntervalsParameter {
+      get { return (ValueParameter<IntValue>)Parameters["MaximumNumberOfIntervals"]; }
+    }
+    private ValueParameter<IntValue> InitialNumberOfRulesParameter {
+      get { return (ValueParameter<IntValue>)Parameters["InitialNumberOfRules"]; }
+    }
+    private ValueParameter<ItemCollection<IDiscretizer>> DiscretizersParameter {
+      get { return (ValueParameter<ItemCollection<IDiscretizer>>)Parameters["Discretizers"]; }
+    }
+    #endregion
+
+    #region Properties
+    public IntValue Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+    public BoolValue SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+    public IntValue PopulationSize {
+      get { return PopulationSizeParameter.Value; }
+      set { PopulationSizeParameter.Value = value; }
+    }
+    public ISelector Selector {
+      get { return SelectorParameter.Value; }
+      set { SelectorParameter.Value = value; }
+    }
+    public PercentValue CrossoverProbability {
+      get { return CrossoverProbabilityParameter.Value; }
+      set { CrossoverProbabilityParameter.Value = value; }
+    }
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IManipulator Mutator {
+      get { return MutatorParameter.Value; }
+      set { MutatorParameter.Value = value; }
+    }
+    public IntValue Elites {
+      get { return ElitesParameter.Value; }
+      set { ElitesParameter.Value = value; }
+    }
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+      set { AnalyzerParameter.Value = value; }
+    }
+    public GAssistSpecialStageMultiOperator SpecialStages {
+      get { return SpecialStagesParameter.Value; }
+      set { SpecialStagesParameter.Value = value; }
+    }
+    public IDiscreteDoubleValueModifier ReinitializeCurveOperator {
+      get { return ReinitializeCurveOperatorParameter.Value; }
+      set { ReinitializeCurveOperatorParameter.Value = value; }
+    }
+    public IntValue MaximumGenerations {
+      get { return MaximumGenerationsParameter.Value; }
+      set { MaximumGenerationsParameter.Value = value; }
+    }
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    private SolutionsCreator SolutionsCreator {
+      get { return (SolutionsCreator)RandomCreator.Successor; }
+    }
+    private GAssistMainLoop GeneticAlgorithmMainLoop {
+      get { return FindMainLoop(SolutionsCreator.Successor); }
+    }
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    #endregion
+
+    public GAssist()
+      : base() {
+      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)));
+      Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueParameter<PercentValue>("CrossoverProbability", "The probability that the Crossover operator is applied on a solution.", new PercentValue(0.9)));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new ValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze each generation.", new MultiAnalyzer()));
+      Parameters.Add(new ValueParameter<GAssistSpecialStageMultiOperator>("SpecialStages", "", new GAssistSpecialStageMultiOperator()));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed.", new IntValue(1000)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("SplitProbability", "", new PercentValue(0.05)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("MergeProbability", "", new PercentValue(0.05)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("StartReinitializeProbability", "", new PercentValue(0.05)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("EndReinitializeProbability", "", new PercentValue(0.0)));
+      Parameters.Add(new FixedValueParameter<PercentValue>("OneProbability", "", new PercentValue(0.75)));
+      Parameters.Add(new FixedValueParameter<IntValue>("MaximumNumberOfIntervals", "", new IntValue(5)));
+      Parameters.Add(new FixedValueParameter<IntValue>("InitialNumberOfRules", "", new IntValue(20)));
+      Parameters.Add(new ConstrainedValueParameter<IDiscreteDoubleValueModifier>("ReinitializeCurveOperator", ""));
+      Parameters.Add(new ValueParameter<ItemCollection<IDiscretizer>>("Discretizers", "", new ItemCollection<IDiscretizer>()));
+
+      RandomCreator randomCreator = new RandomCreator();
+      SolutionsCreator solutionsCreator = new SolutionsCreator();
+      SubScopesCounter subScopesCounter = new SubScopesCounter();
+      ResultsCollector resultsCollector = new ResultsCollector();
+      GAssistMainLoop mainLoop = new GAssistMainLoop();
+      OperatorGraph.InitialOperator = randomCreator;
+
+      randomCreator.RandomParameter.ActualName = "Random";
+      randomCreator.SeedParameter.ActualName = SeedParameter.Name;
+      randomCreator.SeedParameter.Value = null;
+      randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+      randomCreator.SetSeedRandomlyParameter.Value = null;
+      randomCreator.Successor = solutionsCreator;
+
+      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      solutionsCreator.Successor = subScopesCounter;
+
+      subScopesCounter.Name = "Initialize EvaluatedSolutions";
+      subScopesCounter.ValueParameter.ActualName = "EvaluatedSolutions";
+      subScopesCounter.Successor = resultsCollector;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
+      resultsCollector.ResultsParameter.ActualName = "Results";
+      resultsCollector.Successor = mainLoop;
+
+      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      mainLoop.CrossoverProbabilityParameter.ActualName = CrossoverProbabilityParameter.Name;
+      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
+      mainLoop.MaximumGenerationsParameter.ActualName = MaximumGenerationsParameter.Name;
+      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mainLoop.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      mainLoop.SpecialStagesParameter.ActualName = SpecialStagesParameter.Name;
+      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
+      mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      mainLoop.ResultsParameter.ActualName = "Results";
+
+      foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
+        SelectorParameter.ValidValues.Add(selector);
+      ISelector proportionalSelector = SelectorParameter.ValidValues.FirstOrDefault(x => x.GetType().Name.Equals("ProportionalSelector"));
+      if (proportionalSelector != null) SelectorParameter.Value = proportionalSelector;
+      ParameterizeSelectors();
+
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
+
+      foreach (IDiscreteDoubleValueModifier op in ApplicationManager.Manager.GetInstances<IDiscreteDoubleValueModifier>().OrderBy(x => x.Name))
+        ReinitializeCurveOperatorParameter.ValidValues.Add(op);
+      ParameterizeReinitializeCurveOperators();
+
+      InitializeSpecialStages();
+
+      UpdateDiscretizers();
+
+      Initialize();
+    }
+
+    private void UpdateDiscretizers() {
+      // change to add more
+      DiscretizersParameter.Value.AddRange(ApplicationManager.Manager.GetInstances<IDiscretizer>());
+    }
+
+    private void ParameterizeReinitializeCurveOperators() {
+      foreach (IDiscreteDoubleValueModifier op in ReinitializeCurveOperatorParameter.ValidValues) {
+        op.IndexParameter.ActualName = "Generations";
+        op.IndexParameter.Hidden = true;
+        op.StartIndexParameter.Value = new IntValue(0);
+        op.EndIndexParameter.ActualName = MaximumGenerationsParameter.Name;
+        op.ValueParameter.ActualName = "ReinitializeProbability";
+        op.ValueParameter.Hidden = true;
+        op.StartValueParameter.ActualName = StartReinitializeProbabilityParameter.Name;
+        op.StartValueParameter.Hidden = true;
+        op.EndValueParameter.ActualName = EndReinitializeProbabilityParameter.Name;
+        op.EndValueParameter.Hidden = true;
+        ParameterizeStochasticOperator(op);
+      }
+    }
+
+    private void InitializeSpecialStages() {
+      SpecialStages.Operators.Clear();
+      var splitOperator = new SplitOperator();
+      splitOperator.ProbabilityParameter.ActualName = "SplitProbability";
+      SpecialStages.Operators.Add(splitOperator);
+      var mergeOperator = new MergeOperator();
+      mergeOperator.ProbabilityParameter.ActualName = "MergeProbability";
+      SpecialStages.Operators.Add(mergeOperator);
+      var reinitializeOperator = new ReinitializeOperator();
+      reinitializeOperator.ProbabilityParameter.ActualName = "ReinitializeProbability";
+      reinitializeOperator.DiscretizersParameter.ActualName = "Discretizers";
+      reinitializeOperator.OneProbabilityParameter.ActualName = "OneProbability";
+      SpecialStages.Operators.Add(reinitializeOperator);
+      foreach (var op in SpecialStages.Operators) {
+        op.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+      }
+    }
+
+    [StorableConstructor]
+    private GAssist(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    private GAssist(GAssist original, Cloner cloner)
+      : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GAssist(this, cloner);
+    }
+
+    public override void Prepare() {
+      if (Problem != null) base.Prepare();
+    }
+
+    #region Events
+    protected override void OnProblemChanged() {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
+      ParameterizeSolutionsCreator();
+      ParameterizeGeneticAlgorithmMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+      ParameterizeIterationBasedOperators();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateAnalyzers();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.OnProblemChanged();
+    }
+
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeSolutionsCreator();
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeStochasticOperator(Problem.Evaluator);
+      ParameterizeSolutionsCreator();
+      ParameterizeGeneticAlgorithmMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+      Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      foreach (IOperator op in Problem.Operators.OfType<IOperator>()) ParameterizeStochasticOperator(op);
+      ParameterizeIterationBasedOperators();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateAnalyzers();
+      base.Problem_OperatorsChanged(sender, e);
+    }
+    private void ElitesParameter_ValueChanged(object sender, EventArgs e) {
+      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
+      ParameterizeSelectors();
+    }
+    private void Elites_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+
+    private void PopulationSizeParameter_ValueChanged(object sender, EventArgs e) {
+      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
+      ParameterizeSelectors();
+    }
+    private void PopulationSize_ValueChanged(object sender, EventArgs e) {
+      ParameterizeSelectors();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeGeneticAlgorithmMainLoop();
+      ParameterizeSelectors();
+      ParameterizeAnalyzers();
+    }
+    #endregion
+
+    #region Helpers
+    private void Initialize() {
+      PopulationSizeParameter.ValueChanged += new EventHandler(PopulationSizeParameter_ValueChanged);
+      PopulationSize.ValueChanged += new EventHandler(PopulationSize_ValueChanged);
+      ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
+      Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
+      if (Problem != null) {
+        Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      }
+    }
+
+    private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+      // change!
+      ((IGAssistIndividualCreator)Problem.SolutionCreatorParameter.ActualValue).DiscretizersParameter.ActualName = "Discretizers";
+    }
+    private void ParameterizeGeneticAlgorithmMainLoop() {
+      GeneticAlgorithmMainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      GeneticAlgorithmMainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+      GeneticAlgorithmMainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+    }
+    private void ParameterizeStochasticOperator(IOperator op) {
+      IStochasticOperator stochasticOp = op as IStochasticOperator;
+      if (stochasticOp != null) {
+        stochasticOp.RandomParameter.ActualName = RandomCreator.RandomParameter.ActualName;
+        stochasticOp.RandomParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeSelectors() {
+      foreach (ISelector selector in SelectorParameter.ValidValues) {
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * (PopulationSizeParameter.Value.Value - ElitesParameter.Value.Value));
+        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
+        ParameterizeStochasticOperator(selector);
+      }
+      if (Problem != null) {
+        foreach (ISingleObjectiveSelector selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
+          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+          selector.MaximizationParameter.Hidden = true;
+          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+          selector.QualityParameter.Hidden = true;
+        }
+      }
+    }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Depth = 1;
+        qualityAnalyzer.QualityParameter.Hidden = true;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeIterationBasedOperators() {
+      if (Problem != null) {
+        foreach (IIterationBasedOperator op in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          op.IterationsParameter.ActualName = "Generations";
+          op.IterationsParameter.Hidden = true;
+          op.MaximumIterationsParameter.ActualName = "MaximumGenerations";
+          op.MaximumIterationsParameter.Hidden = true;
+        }
+      }
+    }
+    private void UpdateCrossovers() {
+      ICrossover oldCrossover = CrossoverParameter.Value;
+      CrossoverParameter.ValidValues.Clear();
+      ICrossover defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
+
+      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name))
+        CrossoverParameter.ValidValues.Add(crossover);
+
+      if (oldCrossover != null) {
+        ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
+        if (crossover != null) CrossoverParameter.Value = crossover;
+        else oldCrossover = null;
+      }
+      if (oldCrossover == null && defaultCrossover != null)
+        CrossoverParameter.Value = defaultCrossover;
+    }
+    private void UpdateMutators() {
+      IManipulator oldMutator = MutatorParameter.Value;
+      MutatorParameter.ValidValues.Clear();
+      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name))
+        MutatorParameter.ValidValues.Add(mutator);
+      if (oldMutator != null) {
+        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
+        if (mutator != null) MutatorParameter.Value = mutator;
+      }
+    }
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      if (Problem != null) {
+        foreach (IAnalyzer analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          foreach (IScopeTreeLookupParameter param in analyzer.Parameters.OfType<IScopeTreeLookupParameter>())
+            param.Depth = 1;
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+        }
+      }
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+    }
+    private GAssistMainLoop FindMainLoop(IOperator start) {
+      IOperator mainLoop = start;
+      while (mainLoop != null && !(mainLoop is GAssistMainLoop))
+        mainLoop = ((SingleSuccessorOperator)mainLoop).Successor;
+      if (mainLoop == null) return null;
+      else return (GAssistMainLoop)mainLoop;
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssistMainLoop.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssistMainLoop.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/GAssistMainLoop.cs	(revision 9334)
@@ -0,0 +1,260 @@
+#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.GAssist {
+  /// <summary>
+  /// An operator which represents the main loop of a genetic algorithm.
+  /// </summary>
+  [Item("GAssistMainLoop", "An operator which represents the main loop of GAssist.")]
+  [StorableClass]
+  public sealed class GAssistMainLoop : 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<PercentValue> CrossoverProbabilityParameter {
+      get { return (ValueLookupParameter<PercentValue>)Parameters["CrossoverProbability"]; }
+    }
+    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<IOperator> SpecialStagesParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["SpecialStages"]; }
+    }
+    public ValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
+    }
+    public ValueLookupParameter<IntValue> ElitesParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    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 GAssistMainLoop(bool deserializing) : base(deserializing) { }
+    private GAssistMainLoop(GAssistMainLoop original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GAssistMainLoop(this, cloner);
+    }
+    public GAssistMainLoop()
+      : 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<PercentValue>("CrossoverProbability", "The probability that the crossover operator is applied on a solution."));
+      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<IOperator>("SpecialStages", "The operator used for the special stages of GAssist."));
+      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."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      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();
+      StochasticBranch stochasticBranchCrossover = new StochasticBranch();
+      Placeholder crossover = new Placeholder();
+      StochasticBranch stochasticBranchMutator = new StochasticBranch();
+      Placeholder mutator = new Placeholder();
+      Placeholder specialStages = new Placeholder();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
+      Placeholder evaluator = new Placeholder();
+      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);
+
+      stochasticBranchCrossover.ProbabilityParameter.ActualName = "CrossoverProbability";
+      stochasticBranchCrossover.RandomParameter.ActualName = "Random";
+
+      crossover.Name = "Crossover";
+      crossover.OperatorParameter.ActualName = "Crossover";
+
+      stochasticBranchMutator.ProbabilityParameter.ActualName = "MutationProbability";
+      stochasticBranchMutator.RandomParameter.ActualName = "Random";
+
+      mutator.Name = "Mutator";
+      mutator.OperatorParameter.ActualName = "Mutator";
+
+      specialStages.Name = "SpecialStages";
+      specialStages.OperatorParameter.ActualName = "SpecialStages";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      uniformSubScopesProcessor2.Parallel.Value = true;
+
+      evaluator.Name = "Evaluator";
+      evaluator.OperatorParameter.ActualName = "Evaluator";
+
+      subScopesCounter.Name = "Increment EvaluatedSolutions";
+      subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = "Maximization";
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
+      bestSelector.QualityParameter.ActualName = "Quality";
+
+      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 = stochasticBranchCrossover;
+      uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
+      stochasticBranchCrossover.FirstBranch = crossover;
+      stochasticBranchCrossover.SecondBranch = null;
+      stochasticBranchCrossover.Successor = stochasticBranchMutator;
+      crossover.Successor = null;
+      stochasticBranchMutator.FirstBranch = mutator;
+      stochasticBranchMutator.SecondBranch = null;
+      stochasticBranchMutator.Successor = specialStages;
+      mutator.Successor = null;
+      specialStages.Successor = subScopesRemover;
+      subScopesRemover.Successor = null;
+      uniformSubScopesProcessor2.Operator = evaluator;
+      uniformSubScopesProcessor2.Successor = subScopesCounter;
+      evaluator.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.GAssist/3.3/HeuristicLab.Algorithms.GAssist-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/HeuristicLab.Algorithms.GAssist-3.3.csproj	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/HeuristicLab.Algorithms.GAssist-3.3.csproj	(revision 9334)
@@ -0,0 +1,132 @@
+﻿<?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>{F191A6FA-1B3C-4F82-A711-873B4D839BC0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.GAssist</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.GAssist-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.Analysis-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Selection-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Selection-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <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="Discretizer\UniformWidthDiscretizer.cs" />
+    <Compile Include="Interfaces\IDiscretizer.cs" />
+    <Compile Include="Interfaces\IGAssistIndividualCreator.cs" />
+    <Compile Include="Interfaces\IGAssistSpecialStage.cs" />
+    <Compile Include="Interfaces\IGAssistIndividual.cs" />
+    <Compile Include="SpecialStage\GAssistSpecialStageMultiOperator.cs" />
+    <Compile Include="SpecialStage\GAssistSpecialStageOperator.cs" />
+    <Compile Include="SpecialStage\MergeOperator.cs" />
+    <Compile Include="SpecialStage\ReinitializeOperator.cs" />
+    <Compile Include="SpecialStage\SplitOperator.cs" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="GAssist.cs" />
+    <Compile Include="GAssistMainLoop.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- 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.Algorithms.GAssist/3.3/Interfaces/IDiscretizer.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IDiscretizer.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IDiscretizer.cs	(revision 9334)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  public interface IDiscretizer : IItem {
+    int NumberOfMicroIntervals(string attribute);
+    IEnumerable<double> GetCutPoints(string attribute);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividual.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividual.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividual.cs	(revision 9334)
@@ -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 System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  public interface IGAssistIndividual : IItem {
+    void ApplySplit(IRandom random, double probability);
+    void ApplyMerge(IRandom random, double probability);
+    void ApplyReinitialize(IRandom random, double probability, double oneProbability, IEnumerable<IDiscretizer> discretizers);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividualCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividualCreator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistIndividualCreator.cs	(revision 9334)
@@ -0,0 +1,29 @@
+﻿#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.Algorithms.GAssist {
+  public interface IGAssistIndividualCreator : ISolutionCreator {
+    IValueLookupParameter<ItemCollection<IDiscretizer>> DiscretizersParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistSpecialStage.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistSpecialStage.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Interfaces/IGAssistSpecialStage.cs	(revision 9334)
@@ -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.Algorithms.GAssist {
+  public interface IGAssistSpecialStage : IStochasticOperator {
+    ILookupParameter<IGAssistIndividual> IndividualParameter { get; }
+    ILookupParameter<PercentValue> ProbabilityParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Plugin.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Plugin.cs.frame	(revision 9334)
@@ -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.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  [Plugin("HeuristicLab.Algorithms.GAssist", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.GAssist-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabAlgorithmsGAssistPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
@@ -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.Algorithms.GAssist")]
+[assembly: AssemblyDescription("Implementation of GAssist algorithm")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[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("b539f260-b329-4754-a0e5-ccdc1c5541af")]
+
+// 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.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageMultiOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageMultiOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageMultiOperator.cs	(revision 9334)
@@ -0,0 +1,48 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  [Item("GAssistSpecialStageOperator", "Description missing")]
+  [StorableClass]
+  public class GAssistSpecialStageMultiOperator : MultiOperator<IGAssistSpecialStage> {
+
+    [StorableConstructor]
+    protected GAssistSpecialStageMultiOperator(bool deserializing) : base(deserializing) { }
+    protected GAssistSpecialStageMultiOperator(GAssistSpecialStageMultiOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public GAssistSpecialStageMultiOperator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GAssistSpecialStageMultiOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/GAssistSpecialStageOperator.cs	(revision 9334)
@@ -0,0 +1,75 @@
+﻿#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.Algorithms.GAssist {
+  [Item("GAssistSpecialStageOperator", "Description missing")]
+  [StorableClass]
+  public abstract class GAssistSpecialStageOperator : SingleSuccessorOperator, IGAssistSpecialStage {
+
+    #region Parameter Properties
+    public ILookupParameter<IGAssistIndividual> IndividualParameter {
+      get { return (ILookupParameter<IGAssistIndividual>)Parameters["Individual"]; }
+    }
+    public ILookupParameter<PercentValue> ProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["Probability"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    public IGAssistIndividual Individual {
+      get { return IndividualParameter.ActualValue; }
+    }
+    public double Probability {
+      get { return ProbabilityParameter.ActualValue.Value; }
+    }
+    public IRandom Random {
+      get { return RandomParameter.ActualValue; }
+    }
+
+    [StorableConstructor]
+    protected GAssistSpecialStageOperator(bool deserializing) : base(deserializing) { }
+    protected GAssistSpecialStageOperator(GAssistSpecialStageOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public GAssistSpecialStageOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IGAssistIndividual>("Individual"));
+      Parameters.Add(new LookupParameter<PercentValue>("Probability"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+    }
+
+    public sealed override IOperation Apply() {
+      ApplySpecialStage(Individual, Probability, Random);
+      return base.Apply();
+    }
+
+    protected abstract void ApplySpecialStage(IGAssistIndividual individual, double probability, IRandom random);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/MergeOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/MergeOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/MergeOperator.cs	(revision 9334)
@@ -0,0 +1,47 @@
+﻿#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.Algorithms.GAssist {
+  [Item("MergeOperator", "Description missing")]
+  [StorableClass]
+  public class MergeOperator : GAssistSpecialStageOperator {
+
+    [StorableConstructor]
+    protected MergeOperator(bool deserializing) : base(deserializing) { }
+    protected MergeOperator(MergeOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MergeOperator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MergeOperator(this, cloner);
+    }
+
+    protected override void ApplySpecialStage(IGAssistIndividual individual, double probability, IRandom random) {
+      individual.ApplyMerge(random, probability);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/ReinitializeOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/ReinitializeOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/ReinitializeOperator.cs	(revision 9334)
@@ -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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.GAssist {
+  [Item("ReinitializeOperator", "Description missing")]
+  [StorableClass]
+  public class ReinitializeOperator : GAssistSpecialStageOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<ItemArray<IDiscretizer>> DiscretizersParameter {
+      get { return (ILookupParameter<ItemArray<IDiscretizer>>)Parameters["Discretizers"]; }
+    }
+    public ILookupParameter<PercentValue> OneProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["OneProbability"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ReinitializeOperator(bool deserializing) : base(deserializing) { }
+    protected ReinitializeOperator(ReinitializeOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ReinitializeOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<ItemArray<IDiscretizer>>("Discretizers", ""));
+      Parameters.Add(new LookupParameter<PercentValue>("OneProbability", ""));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReinitializeOperator(this, cloner);
+    }
+
+    protected override void ApplySpecialStage(IGAssistIndividual individual, double probability, IRandom random) {
+      individual.ApplyReinitialize(random, probability, OneProbabilityParameter.ActualValue.Value, DiscretizersParameter.ActualValue);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/SplitOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/SplitOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.GAssist/3.3/SpecialStage/SplitOperator.cs	(revision 9334)
@@ -0,0 +1,47 @@
+﻿#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.Algorithms.GAssist {
+  [Item("SplitOperator", "Description missing")]
+  [StorableClass]
+  public class SplitOperator : GAssistSpecialStageOperator {
+
+    [StorableConstructor]
+    protected SplitOperator(bool deserializing) : base(deserializing) { }
+    protected SplitOperator(SplitOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SplitOperator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SplitOperator(this, cloner);
+    }
+
+    protected override void ApplySpecialStage(IGAssistIndividual individual, double probability, IRandom random) {
+      individual.ApplySplit(random, probability);
+    }
+  }
+}
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 9333)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9334)
@@ -66,7 +66,4 @@
     </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">
       <Private>False</Private>
     </Reference>
@@ -150,4 +147,8 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
+      <Project>{df87c13e-a889-46ff-8153-66dcaa8c5674}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs	(revision 9334)
@@ -0,0 +1,44 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IAction : IItem {
+    string VariableName { get; }
+
+    int Possibilities { get; }
+    void Randomize(IRandom random);
+
+    bool Match(IAction action);
+    void SetTo(string value);
+
+    IEnumerable<int> GetPossibleActionPositions();
+    void SetToPosition(int value);
+    int CurrentPosition { get; }
+  }
+
+  public interface IAction<T> : IAction {
+    T CurrentAction { get; }
+    IEnumerable<T> GetPossibleActions();
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs	(revision 9334)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("IntAction", "")]
+  public class IntAction : Item, IAction<int> {
+
+    [Storable]
+    protected string variableName;
+    public string VariableName {
+      get { return variableName; }
+    }
+
+    [Storable]
+    protected IList<int> possibleFeatures;
+    public IEnumerable<int> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [Storable]
+    protected int currentAction;
+    public int CurrentAction {
+      get { return currentAction; }
+    }
+
+    public int CurrentPosition {
+      get { return CurrentAction; }
+    }
+
+    public int Possibilities { get { return possibleFeatures.Count(); } }
+
+    [StorableConstructor]
+    protected IntAction(bool deserializing) : base(deserializing) { }
+    protected IntAction(IntAction original, Cloner cloner)
+      : base(original, cloner) {
+      variableName = original.variableName;
+      possibleFeatures = new List<int>(original.possibleFeatures);
+      currentAction = original.currentAction;
+    }
+    public IntAction(string variableName, IList<int> variableValues)
+      : base() {
+      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
+      }
+      this.possibleFeatures = variableValues;
+      this.variableName = variableName;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntAction(this, cloner);
+    }
+
+    public IEnumerable<int> GetPossibleActionPositions() {
+      return possibleFeatures;
+    }
+
+    public IEnumerable<int> GetPossibleActions() {
+      return PossibleFeatures;
+    }
+
+    public void Randomize(IRandom random) {
+      currentAction = possibleFeatures.ElementAt(random.Next(0, possibleFeatures.Count()));
+    }
+
+    public bool Match(IAction action) {
+      var targetCast = action as IntAction;
+      return targetCast != null && this.variableName.Equals(targetCast.VariableName) && CurrentAction.Equals(targetCast.CurrentAction);
+    }
+
+    public void SetTo(string value) {
+      currentAction = int.Parse(value);
+    }
+
+    public void SetToPosition(int value) {
+      if (!possibleFeatures.Contains(value)) { throw new ArgumentOutOfRangeException(); }
+      currentAction = value;
+    }
+
+    public override string ToString() {
+      return currentAction.ToString();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs	(revision 9334)
@@ -0,0 +1,112 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("StringAction", "")]
+  public class StringAction : Item, IAction<string> {
+
+    [Storable]
+    protected string variableName;
+    public string VariableName {
+      get { return variableName; }
+    }
+
+    [Storable]
+    protected IList<string> possibleFeatures;
+    public IEnumerable<string> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [Storable]
+    protected int currentActionIndex;
+    public int CurrentActionIndex {
+      get { return currentActionIndex; }
+    }
+
+    public int CurrentPosition {
+      get { return CurrentActionIndex; }
+    }
+
+    public string CurrentAction {
+      get { return possibleFeatures[currentActionIndex]; }
+    }
+
+    public int Possibilities { get { return possibleFeatures.Count; } }
+
+    [StorableConstructor]
+    protected StringAction(bool deserializing) : base(deserializing) { }
+    protected StringAction(StringAction original, Cloner cloner)
+      : base(original, cloner) {
+      variableName = original.variableName;
+      possibleFeatures = new List<string>(original.possibleFeatures);
+      currentActionIndex = original.currentActionIndex;
+    }
+    public StringAction(string variableName, IList<string> variableValues)
+      : base() {
+      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
+      }
+      this.possibleFeatures = variableValues;
+      this.variableName = variableName;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StringAction(this, cloner);
+    }
+
+    public IEnumerable<int> GetPossibleActionPositions() {
+      return Enumerable.Range(0, possibleFeatures.Count);
+    }
+
+    public IEnumerable<string> GetPossibleActions() {
+      return PossibleFeatures;
+    }
+
+    public void Randomize(IRandom random) {
+      currentActionIndex = random.Next(0, possibleFeatures.Count());
+    }
+
+    public bool Match(IAction action) {
+      var targetCast = action as StringAction;
+      return targetCast != null && this.variableName.Equals(targetCast.VariableName) && CurrentAction.Equals(targetCast.CurrentAction);
+    }
+
+    public void SetTo(string value) {
+      currentActionIndex = possibleFeatures.IndexOf(value);
+    }
+
+    public void SetToPosition(int value) {
+      if (value < 0 || value > possibleFeatures.Count) { throw new ArgumentOutOfRangeException(); }
+      currentActionIndex = value;
+    }
+
+    public override string ToString() {
+      return CurrentAction;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs	(revision 9334)
@@ -0,0 +1,55 @@
+﻿#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.Algorithms.GAssist;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("UniformRandomDecisionListCreator", "Description missing")]
+  [StorableClass]
+  public class UniformRandomDecisionListCreator : DecisionListCreator {
+
+    [StorableConstructor]
+    protected UniformRandomDecisionListCreator(bool deserializing) : base(deserializing) { }
+    protected UniformRandomDecisionListCreator(UniformRandomDecisionListCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformRandomDecisionListCreator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformRandomDecisionListCreator(this, cloner);
+    }
+
+    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers) {
+      List<Rule> rules = new List<Rule>();
+      for (int i = 0; i < initialNumberOfRules; i++) {
+        var newRule = (Rule)sampleRule.Clone();
+        newRule.Randomize(random, oneProbability, discretizers);
+        rules.Add(newRule);
+      }
+      return new DecisionList(rules);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Crossover/SinglePointCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Crossover/SinglePointCrossover.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Crossover/SinglePointCrossover.cs	(revision 9334)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList.Crossover {
+  [Item("SinglePointCrossover", "Description missing")]
+  [StorableClass]
+  public class SinglePointCrossover : DecisionListCrossover {
+
+    #region Parameter Properties
+    #endregion
+
+    [StorableConstructor]
+    protected SinglePointCrossover(bool deserializing) : base(deserializing) { }
+    protected SinglePointCrossover(SinglePointCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SinglePointCrossover()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SinglePointCrossover(this, cloner);
+    }
+
+    public static DecisionList Apply(IRandom random, DecisionList parent1, DecisionList parent2) {
+      int rulesP1 = random.Next(0, parent1.Rules.Count());
+      int rulesP2 = random.Next(0, parent2.Rules.Count());
+
+      var rules = new List<Rule>(rulesP1 + rulesP2);
+      for (int i = 0; i < rulesP1; i++) {
+        rules.Add((Rule)parent1.Rules[i].Clone());
+      }
+
+      rules.Add(parent1.Rules[rulesP1].Crossover(parent2.Rules[rulesP2], random));
+
+      for (int i = rulesP2 + 1; i < parent2.Rules.Count(); i++) {
+        rules.Add((Rule)parent2.Rules[i].Clone());
+      }
+
+      return new DecisionList(rules);
+    }
+
+    protected override DecisionList Cross(IRandom random, ItemArray<DecisionList> parents) {
+      if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs	(revision 9334)
@@ -0,0 +1,98 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("DecisionList", "")]
+  public class DecisionList : Item {
+    [Storable]
+    private IList<Rule> rules;
+    public IList<Rule> Rules {
+      get { return rules; }
+    }
+
+    [Storable]
+    private IAction defaultAction;
+    public IAction DefaultAction {
+      get { return defaultAction; }
+    }
+
+    [StorableConstructor]
+    protected DecisionList(bool deserializing) : base(deserializing) { }
+    protected DecisionList(DecisionList original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionList()
+      : base() {
+      rules = new List<Rule>();
+      defaultAction = null;
+    }
+    public DecisionList(List<Rule> rules)
+      : base() {
+      this.rules = rules;
+      defaultAction = null;
+    }
+    public DecisionList(List<Rule> rules, IAction defaultAction)
+      : base() {
+      if (rules.Any(x => x.Action.Match(defaultAction))) { throw new ArgumentException("If a default action is used. The default action is not allowed be used in any rule."); }
+      this.rules = rules;
+      this.defaultAction = defaultAction;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecisionList(this, cloner);
+    }
+
+    // for convenience
+    public IEnumerable<IAction> Evaluate(IEnumerable<DecisionListInput> input) {
+      int numberOfAliveRules;
+      return Evaluate(input, out numberOfAliveRules);
+    }
+    // for convenience
+    public IEnumerable<IAction> Evaluate(IEnumerable<DecisionListInput> input, out int numberOfAliveRules) {
+      double theoryLengtgh;
+      return Evaluate(input, out numberOfAliveRules, out theoryLengtgh);
+    }
+    public IEnumerable<IAction> Evaluate(IEnumerable<DecisionListInput> input, out int numberOfAliveRules, out double theoryLengtgh) {
+      var estimated = new List<IAction>();
+      var activatedRules = new HashSet<Rule>();
+      foreach (var dli in input) {
+        foreach (var rule in rules) {
+          if (rule.MatchInput(dli)) {
+            estimated.Add(rule.Action);
+            activatedRules.Add(rule);
+            break;
+          }
+        }
+      }
+      numberOfAliveRules = activatedRules.Count;
+      theoryLengtgh = activatedRules.Sum(x => x.ComputeTheoryLength());
+
+      return estimated;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs	(revision 9334)
@@ -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.Algorithms.GAssist;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("DecisionListCreator", "Description missing")]
+  [StorableClass]
+  public abstract class DecisionListCreator : SingleSuccessorOperator, IDecisionListCreator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+    public IValueLookupParameter<IntValue> InitialNumberOfRulesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["InitialNumberOfRules"]; }
+    }
+    public IValueLookupParameter<PercentValue> OneProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["OneProbability"]; }
+    }
+    public IValueLookupParameter<ItemCollection<IDiscretizer>> DiscretizersParameter {
+      get { return (IValueLookupParameter<ItemCollection<IDiscretizer>>)Parameters["Discretizers"]; }
+    }
+    public ILookupParameter<DecisionList> DecisionListParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["DecisionList"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListCreator(bool deserializing) : base(deserializing) { }
+    protected DecisionListCreator(DecisionListCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionListCreator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("InitialNumberOfRules", ""));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("OneProbability", ""));
+      Parameters.Add(new ValueLookupParameter<ItemCollection<IDiscretizer>>("Discretizers", ""));
+      Parameters.Add(new LookupParameter<DecisionList>("DecisionList", ""));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+
+    }
+
+    public override IOperation Apply() {
+      DecisionListParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemDataParameter.ActualValue.SampleRuleParameter.Value, InitialNumberOfRulesParameter.ActualValue.Value, OneProbabilityParameter.ActualValue.Value, DiscretizersParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCrossover.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCrossover.cs	(revision 9334)
@@ -0,0 +1,66 @@
+﻿#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.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("DecisionListCrossover", "Description missing")]
+  [StorableClass]
+  public abstract class DecisionListCrossover : SingleSuccessorOperator, IDecisionListCrossover {
+
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<DecisionList>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<DecisionList>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<DecisionList> ChildParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["Child"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListCrossover(bool deserializing) : base(deserializing) { }
+    protected DecisionListCrossover(DecisionListCrossover original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionListCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new ScopeTreeLookupParameter<DecisionList>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "DecisionList";
+      Parameters.Add(new LookupParameter<DecisionList>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "DecisionList";
+    }
+
+    public override IOperation Apply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract DecisionList Cross(IRandom random, ItemArray<DecisionList> parents);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListInput.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListInput.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListInput.cs	(revision 9334)
@@ -0,0 +1,84 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("DecisionListInput", "")]
+  public class DecisionListInput : Item {
+
+    [Storable]
+    private Dictionary<string, string> inputDictionary;
+    public Dictionary<string, string> InputDictionary {
+      get { return inputDictionary; }
+      protected set {
+        inputDictionary = value;
+      }
+    }
+
+    public IOrderedEnumerable<string> Order { get { return InputDictionary.Keys.OrderBy(x => x); } }
+
+    [StorableConstructor]
+    protected DecisionListInput(bool deserializing) { }
+    protected DecisionListInput(DecisionListInput original, Cloner cloner) {
+      InputDictionary = new Dictionary<string, string>(original.InputDictionary.Count);
+      foreach (var item in original.InputDictionary) {
+        InputDictionary.Add(item.Key, item.Value);
+      }
+    }
+    public DecisionListInput()
+      : base() {
+      InputDictionary = new Dictionary<string, string>();
+    }
+    public DecisionListInput(int capacity)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(capacity);
+    }
+    public DecisionListInput(IDictionary<string, string> dictionary)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecisionListInput(this, cloner);
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      bool first = true;
+      foreach (var item in InputDictionary) {
+        if (first) {
+          first = false;
+        } else {
+          sb.Append("; ");
+        }
+        sb.Append(String.Format("{0}: {1}", item.Key, item.Value));
+      }
+      return sb.ToString();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListManipulator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListManipulator.cs	(revision 9334)
@@ -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.DecisionList {
+  [Item("DecisionListManipulator", "Description missing")]
+  [StorableClass]
+  public abstract class DecisionListManipulator : SingleSuccessorOperator, IDecisionListManipulator {
+
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DecisionList> ChildParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["Child"]; }
+    }
+    public ILookupParameter<PercentValue> ActionMutationProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["ActionMutationProbability"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListManipulator(bool deserializing) : base(deserializing) { }
+    protected DecisionListManipulator(DecisionListManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionListManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+      Parameters.Add(new LookupParameter<DecisionList>("Child"));
+      Parameters.Add(new LookupParameter<PercentValue>("ActionMutationProbability"));
+    }
+
+    public override IOperation Apply() {
+      Manipulate(RandomParameter.ActualValue, ChildParameter.ActualValue, ActionMutationProbabilityParameter.ActualValue.Value);
+      return base.Apply();
+    }
+
+    protected abstract void Manipulate(IRandom random, DecisionList child, double actionMutationProbability);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9334)
@@ -0,0 +1,234 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("DecisionListSolution", "Represents a DecisionList solution.")]
+  public class DecisionListSolution : ResultCollection, IDecisionListSolution {
+    private const string ModelResultName = "Model";
+    private const string ProblemDataResultName = "ProblemData";
+    private const string TrainingAccuracyResultName = "Accuracy (training)";
+    private const string TestAccuracyResultName = "Accuracy (test)";
+    private const string TrainingNumberOfAliveRulesName = "Number of alive rules (training)";
+    //private const string TestNumberOfAliveRules = "Number of alive rules (test)";
+    private const string TrainingTheoryLengthName = "Theory Length (training)";
+    private const string TrainingExceptionsLengthName = "Exceptions Length (training)";
+
+    public double TrainingAccuracy {
+      get { return ((PercentValue)this[TrainingAccuracyResultName].Value).Value; }
+      private set { ((PercentValue)this[TrainingAccuracyResultName].Value).Value = value; }
+    }
+    public double TestAccuracy {
+      get { return ((PercentValue)this[TestAccuracyResultName].Value).Value; }
+      private set { ((PercentValue)this[TestAccuracyResultName].Value).Value = value; }
+    }
+    public int TrainingNumberOfAliveRules {
+      get { return ((IntValue)this[TrainingNumberOfAliveRulesName].Value).Value; }
+      private set { ((IntValue)this[TrainingNumberOfAliveRulesName].Value).Value = value; }
+    }
+    public double TrainingTheoryLength {
+      get { return ((DoubleValue)this[TrainingTheoryLengthName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingTheoryLengthName].Value).Value = value; }
+    }
+    public double TrainingExceptionsLength {
+      get { return ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value = value; }
+    }
+
+    DecisionList IDecisionListSolution.Model {
+      get { return Model; }
+    }
+
+    public DecisionList Model {
+      get { return (DecisionList)this[ModelResultName].Value; ; }
+      protected set {
+        if (this[ModelResultName].Value != value) {
+          if (value != null) {
+            this[ModelResultName].Value = value;
+            OnModelChanged();
+          }
+        }
+      }
+    }
+
+    public IDecisionListClassificationProblemData ProblemData {
+      get { return (IDecisionListClassificationProblemData)this[ProblemDataResultName].Value; }
+      set {
+        if (this[ProblemDataResultName].Value != value) {
+          if (value != null) {
+            ProblemData.Changed -= new EventHandler(ProblemData_Changed);
+            this[ProblemDataResultName].Value = value;
+            ProblemData.Changed += new EventHandler(ProblemData_Changed);
+            OnProblemDataChanged();
+          }
+        }
+      }
+    }
+
+    [StorableConstructor]
+    protected DecisionListSolution(bool deserializing) : base(deserializing) { }
+    protected DecisionListSolution(DecisionListSolution original, Cloner cloner)
+      : base(original, cloner) {
+      name = original.Name;
+      description = original.Description;
+    }
+    public DecisionListSolution(DecisionList model, IDecisionListClassificationProblemData problemData)
+      : base() {
+      name = ItemName;
+      description = ItemDescription;
+      Add(new Result(ModelResultName, "Decision List.", model));
+      Add(new Result(ProblemDataResultName, "The problem data.", problemData));
+      Add(new Result(TrainingAccuracyResultName, "Accuracy of the model on the training partition (percentage of correctly classified instances).", new PercentValue()));
+      Add(new Result(TestAccuracyResultName, "Accuracy of the model on the test partition (percentage of correctly classified instances).", new PercentValue()));
+      Add(new Result(TrainingNumberOfAliveRulesName, "", new IntValue()));
+      Add(new Result(TrainingTheoryLengthName, "", new DoubleValue()));
+      Add(new Result(TrainingExceptionsLengthName, "", new DoubleValue()));
+
+      problemData.Changed += new EventHandler(ProblemData_Changed);
+
+      RecalculateResults();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecisionListSolution(this, cloner);
+    }
+
+    private void RecalculateResults() {
+      var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
+      var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
+      int numberOfAliveRules;
+      double theoryLength;
+      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out numberOfAliveRules, out theoryLength);
+      TrainingNumberOfAliveRules = numberOfAliveRules;
+      TrainingTheoryLength = theoryLength;
+      var estimatedTest = Model.Evaluate(originalTestCondition);
+
+      var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);
+      var originalTestAction = ProblemData.FetchAction(ProblemData.TestIndices);
+
+      TrainingAccuracy = CalculateAccuracy(originalTrainingAction, estimatedTraining);
+      TestAccuracy = CalculateAccuracy(originalTestAction, estimatedTest);
+
+      TrainingExceptionsLength = 105.0 - TrainingAccuracy * 100.0;
+    }
+
+    private double CalculateAccuracy(IEnumerable<IAction> original, IEnumerable<IAction> estimated) {
+      double correctClassified = 0;
+
+      double rows = original.Count();
+      var originalEnumerator = original.GetEnumerator();
+      var estimatedActionEnumerator = estimated.GetEnumerator();
+
+      while (originalEnumerator.MoveNext() && estimatedActionEnumerator.MoveNext()) {
+        if (originalEnumerator.Current.Match(estimatedActionEnumerator.Current)) {
+          correctClassified++;
+        }
+      }
+      return correctClassified / rows;
+    }
+
+    private void ProblemData_Changed(object sender, EventArgs e) {
+      OnProblemDataChanged();
+    }
+
+    public event EventHandler ModelChanged;
+    protected virtual void OnModelChanged() {
+      RecalculateResults();
+      var listeners = ModelChanged;
+      if (listeners != null) listeners(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ProblemDataChanged;
+    protected virtual void OnProblemDataChanged() {
+      RecalculateResults();
+      var listeners = ProblemDataChanged;
+      if (listeners != null) listeners(this, EventArgs.Empty);
+    }
+
+    #region INamedItem Members
+    [Storable]
+    protected string name;
+    public string Name {
+      get { return name; }
+      set {
+        if (!CanChangeName) throw new NotSupportedException("Name cannot be changed.");
+        if (!(name.Equals(value) || (value == null) && (name == string.Empty))) {
+          CancelEventArgs<string> e = value == null ? new CancelEventArgs<string>(string.Empty) : new CancelEventArgs<string>(value);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            name = value == null ? string.Empty : value;
+            OnNameChanged();
+          }
+        }
+      }
+    }
+    public virtual bool CanChangeName {
+      get { return true; }
+    }
+    [Storable]
+    protected string description;
+    public string Description {
+      get { return description; }
+      set {
+        if (!CanChangeDescription) throw new NotSupportedException("Description cannot be changed.");
+        if (!(description.Equals(value) || (value == null) && (description == string.Empty))) {
+          description = value == null ? string.Empty : value;
+          OnDescriptionChanged();
+        }
+      }
+    }
+    public virtual bool CanChangeDescription {
+      get { return true; }
+    }
+
+    public override string ToString() {
+      return Name;
+    }
+
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    protected virtual void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+
+    public event EventHandler NameChanged;
+    protected virtual void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnToStringChanged();
+    }
+
+    public event EventHandler DescriptionChanged;
+    protected virtual void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    #endregion
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/DecisionListEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/DecisionListEvaluator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/DecisionListEvaluator.cs	(revision 9334)
@@ -0,0 +1,104 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("DecisionListEvaluator", "Description missing")]
+  [StorableClass]
+  public abstract class DecisionListEvaluator : SingleSuccessorOperator, IDecisionListEvaluator, IDecisionListOperator, IStochasticOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DecisionList> DecisionListParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["DecisionList"]; }
+    }
+    public IValueLookupParameter<IntRange> EvaluationPartitionParameter {
+      get { return (IValueLookupParameter<IntRange>)Parameters["EvaluationPartition"]; }
+    }
+    public IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["RelativeNumberOfEvaluatedSamples"]; }
+    }
+    public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+    public IValueLookupParameter<IntValue> SizePenaltyMinRulesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SizePenaltyMinRules"]; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListEvaluator(bool deserializing) : base(deserializing) { }
+    protected DecisionListEvaluator(DecisionListEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionListEvaluator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random generator to use."));
+      Parameters.Add(new LookupParameter<DecisionList>("DecisionList", ""));
+      Parameters.Add(new ValueLookupParameter<IntRange>("EvaluationPartition", ""));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("RelativeNumberOfEvaluatedSamples", ""));
+      Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SizePenaltyMinRules", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", ""));
+    }
+
+    protected IEnumerable<int> GenerateRowsToEvaluate() {
+      return GenerateRowsToEvaluate(RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value);
+    }
+
+    protected IEnumerable<int> GenerateRowsToEvaluate(double percentageOfRows) {
+      IEnumerable<int> rows;
+      int samplesStart = EvaluationPartitionParameter.ActualValue.Start;
+      int samplesEnd = EvaluationPartitionParameter.ActualValue.End;
+      int testPartitionStart = ProblemDataParameter.ActualValue.TestPartition.Start;
+      int testPartitionEnd = ProblemDataParameter.ActualValue.TestPartition.End;
+      if (samplesEnd < samplesStart) throw new ArgumentException("Start value is larger than end value.");
+
+      if (percentageOfRows.IsAlmost(1.0))
+        rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart);
+      else {
+        int seed = RandomParameter.ActualValue.Next();
+        int count = (int)((samplesEnd - samplesStart) * percentageOfRows);
+        if (count == 0) count = 1;
+        rows = RandomEnumerable.SampleRandomNumbers(seed, samplesStart, samplesEnd, count);
+      }
+
+      rows = rows.Where(i => i < testPartitionStart || testPartitionEnd <= i);
+      return rows;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLCalculator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLCalculator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLCalculator.cs	(revision 9334)
@@ -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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("MDLCalculator", "")]
+  public class MDLCalculator : Item {
+
+    [Storable]
+    private int activationIteration;
+
+    [Storable]
+    private bool activated;
+    [Storable]
+    private bool fixedWeight;
+
+    [Storable]
+    private double theoryWeight;
+
+    [Storable]
+    private double initialTheoryLengthRatio;
+    [Storable]
+    private double weightRelaxFactor;
+
+    [Storable]
+    private IList<double> accuracyStatistic;
+    [Storable]
+    private int iterationsSinceBest;
+    [Storable]
+    private double bestFitness;
+
+    [StorableConstructor]
+    protected MDLCalculator(bool deserializing) : base(deserializing) { }
+    protected MDLCalculator(MDLCalculator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MDLCalculator(int activationIteration, double initialTheoryLengthRatio, double weightRelaxFactor)
+      : base() {
+      this.activationIteration = activationIteration;
+      this.initialTheoryLengthRatio = initialTheoryLengthRatio;
+      this.weightRelaxFactor = weightRelaxFactor;
+      activated = false;
+      fixedWeight = false;
+      accuracyStatistic = new List<double>();
+      iterationsSinceBest = 0;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MDLCalculator(this, cloner);
+    }
+
+    public void StartNewIteration(DecisionListSolution bestSolution, int currentIteration) {
+      if (currentIteration == activationIteration) {
+        activated = true;
+        double error = bestSolution.TrainingExceptionsLength;
+        double tl = (bestSolution.TrainingTheoryLength * bestSolution.ProblemData.Classes) / bestSolution.TrainingNumberOfAliveRules;
+        theoryWeight = (initialTheoryLengthRatio / (1.0 - initialTheoryLengthRatio)) * (error / tl);
+        iterationsSinceBest = 0;
+      }
+
+      if (activated && !fixedWeight &&
+        GetLastIterationsAccuracyAverage(10) == 1.0) {
+        fixedWeight = true;
+      }
+
+      if (activated && !fixedWeight) {
+        if (bestSolution.TrainingAccuracy != 1.0) {
+          if (iterationsSinceBest == 10) {
+            theoryWeight *= weightRelaxFactor;
+            iterationsSinceBest = 0;
+          }
+        }
+      }
+
+      if (currentIteration != 0) {
+        UpdateStatistic(bestSolution.TrainingAccuracy);
+      }
+    }
+
+    private void UpdateStatistic(double accuracy) {
+      if (iterationsSinceBest == 0) {
+        bestFitness = accuracy;
+        iterationsSinceBest++;
+      } else if (accuracy > bestFitness) {
+        bestFitness = accuracy;
+        iterationsSinceBest = 1;
+      } else {
+        iterationsSinceBest++;
+      }
+    }
+
+    private double GetLastIterationsAccuracyAverage(int iterations) {
+      int startAt = accuracyStatistic.Count - iterations;
+      startAt = startAt > 0 ? startAt : 0;
+      return accuracyStatistic.Skip(startAt).Sum() / (accuracyStatistic.Count - startAt);
+    }
+
+    public double CalculateFitness(DecisionListSolution dls) {
+      double fitness = 0;
+      if (activated) {
+        fitness = dls.TrainingTheoryLength * theoryWeight;
+      }
+      fitness += 105.0 - dls.TrainingAccuracy * 100.0;
+      return fitness;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9334)
@@ -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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("MDLEvaluator", "Description missing")]
+  [StorableClass]
+  public class MDLEvaluator : DecisionListEvaluator {
+
+    public IValueLookupParameter<MDLCalculator> MDLCalculatorParameter {
+      get { return (IValueLookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
+    }
+
+    [StorableConstructor]
+    protected MDLEvaluator(bool deserializing) : base(deserializing) { }
+    protected MDLEvaluator(MDLEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MDLEvaluator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<MDLCalculator>("MDLCalculator", ""));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MDLEvaluator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      double penalty = 1;
+
+      var dls = new DecisionListSolution(DecisionListParameter.ActualValue, ProblemDataParameter.ActualValue);
+
+      if (dls.TrainingNumberOfAliveRules < SizePenaltyMinRulesParameter.ActualValue.Value) {
+        penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - dls.TrainingNumberOfAliveRules));
+        if (penalty <= 0) penalty = 0.01;
+        penalty *= penalty;
+      }
+
+      QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(dls) / penalty);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLIterationOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLIterationOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLIterationOperator.cs	(revision 9334)
@@ -0,0 +1,85 @@
+﻿#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.DecisionList.Evaluator {
+  [Item("MDLIterationOperator", "Description missing")]
+  [StorableClass]
+  public class MDLIterationOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<DecisionList> DecisionListParameter {
+      get { return (ILookupParameter<DecisionList>)Parameters["DecisionList"]; }
+    }
+    public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+    public IValueLookupParameter<MDLCalculator> MDLCalculatorParameter {
+      get { return (IValueLookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
+    }
+    public IValueLookupParameter<IntValue> IterationParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Iteration"]; }
+    }
+    public IValueLookupParameter<IntValue> MDLIterationParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MDLIteration"]; }
+    }
+    public IValueLookupParameter<DoubleValue> InitialTheoryLengthRationParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["InitialTheoryLengthRation"]; }
+    }
+    public IValueLookupParameter<DoubleValue> WeightRelaxFactorParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["WeightRelaxFactor"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected MDLIterationOperator(bool deserializing) : base(deserializing) { }
+    protected MDLIterationOperator(MDLIterationOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MDLIterationOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<DecisionList>("DecisionList", ""));
+      Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Iteration", ""));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MDLIteration", ""));
+      Parameters.Add(new ValueLookupParameter<MDLCalculator>("MDLCalculator", ""));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MDLIterationOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (MDLCalculatorParameter.ActualValue == null) {
+        MDLCalculatorParameter.ActualValue = new MDLCalculator(MDLIterationParameter.ActualValue.Value,
+                                                               InitialTheoryLengthRationParameter.ActualValue.Value,
+                                                               WeightRelaxFactorParameter.ActualValue.Value);
+      }
+      MDLCalculatorParameter.ActualValue.StartNewIteration(new DecisionListSolution(DecisionListParameter.ActualValue, ProblemDataParameter.ActualValue), IterationParameter.ActualValue.Value);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/HeuristicLab.Encodings.DecisionList-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/HeuristicLab.Encodings.DecisionList-3.3.csproj	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/HeuristicLab.Encodings.DecisionList-3.3.csproj	(revision 9334)
@@ -0,0 +1,150 @@
+﻿<?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>{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.DecisionList</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.DecisionList-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>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <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="Action\StringAction.cs" />
+    <Compile Include="Action\IAction.cs" />
+    <Compile Include="Action\IntAction.cs" />
+    <Compile Include="Creators\UniformRandomDecisionListCreator.cs" />
+    <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="DecisionListCreator.cs" />
+    <Compile Include="DecisionListCrossover.cs" />
+    <Compile Include="DecisionListManipulator.cs" />
+    <Compile Include="DecisionListSolution.cs" />
+    <Compile Include="Evaluator\DecisionListEvaluator.cs" />
+    <Compile Include="Evaluator\MDLCalculator.cs" />
+    <Compile Include="Evaluator\MDLEvaluator.cs" />
+    <Compile Include="Evaluator\MDLIterationOperator.cs" />
+    <Compile Include="Interfaces\IDecisionListClassificationProblem.cs" />
+    <Compile Include="Interfaces\IDecisionListClassificationProblemData.cs" />
+    <Compile Include="Interfaces\IDecisionListCreator.cs" />
+    <Compile Include="Interfaces\IDecisionListCrossover.cs" />
+    <Compile Include="Interfaces\IDecisionListEvaluator.cs" />
+    <Compile Include="Interfaces\IDecisionListManipulator.cs" />
+    <Compile Include="Interfaces\IDecisionListOperator.cs" />
+    <Compile Include="Interfaces\IDecisionListSolution.cs" />
+    <Compile Include="DecisionListInput.cs" />
+    <Compile Include="Manipulator\UniformOnePointManipulator.cs" />
+    <Compile Include="Variable\DoubleVariable.cs" />
+    <Compile Include="Variable\StringVariable.cs" />
+    <Compile Include="Variable\IntVariable.cs" />
+    <Compile Include="Variable\IVariable.cs" />
+    <Compile Include="Variable\Variable.cs" />
+    <Compile Include="Rule.cs" />
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="DecisionList.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Algorithms.GAssist\3.3\HeuristicLab.Algorithms.GAssist-3.3.csproj">
+      <Project>{f191a6fa-1b3c-4f82-a711-873b4d839bc0}</Project>
+      <Name>HeuristicLab.Algorithms.GAssist-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
+      <Project>{df87c13e-a889-46ff-8153-66dcaa8c5674}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
+    </ProjectReference>
+  </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.DecisionList/3.3/Interfaces/IDecisionListClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListClassificationProblem.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListClassificationProblem.cs	(revision 9334)
@@ -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.Optimization;
+
+namespace HeuristicLab.Encodings.DecisionList.Interfaces {
+  public interface IDecisionListClassificationProblem : ISingleObjectiveHeuristicOptimizationProblem {
+    IParameter ProblemDataParameter { get; }
+    IDecisionListClassificationProblemData ProblemData { get; }
+    new IDecisionListEvaluator Evaluator { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListClassificationProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListClassificationProblemData.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListClassificationProblemData.cs	(revision 9334)
@@ -0,0 +1,56 @@
+﻿#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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IDecisionListClassificationProblemData : INamedItem {
+    Dataset Dataset { get; }
+    ICheckedItemList<StringValue> ConditionVariables { get; }
+    StringValue TargetVariable { get; }
+    IEnumerable<string> AllowedConditionVariables { get; }
+    //IEnumerable<string> AllowedTargetVariables { get; }
+
+    IntRange TrainingPartition { get; }
+    IntRange TestPartition { get; }
+
+    IEnumerable<int> TrainingIndices { get; }
+    IEnumerable<int> TestIndices { get; }
+
+    bool IsTrainingSample(int index);
+    bool IsTestSample(int index);
+
+    int Classes { get; }
+
+    IFixedValueParameter<Rule> SampleRuleParameter { get; }
+
+    DecisionListInput FetchInput(int row);
+    IEnumerable<DecisionListInput> FetchInput(IEnumerable<int> row);
+
+    IEnumerable<IAction> FetchAction(IEnumerable<int> rows);
+
+    event EventHandler Changed;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs	(revision 9334)
@@ -0,0 +1,34 @@
+﻿#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.Algorithms.GAssist;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IDecisionListCreator : IDecisionListOperator, ISolutionCreator, IStochasticOperator, IGAssistIndividualCreator {
+    IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }
+    ILookupParameter<DecisionList> DecisionListParameter { get; }
+    IValueLookupParameter<IntValue> InitialNumberOfRulesParameter { get; }
+    IValueLookupParameter<PercentValue> OneProbabilityParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCrossover.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCrossover.cs	(revision 9334)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IDecisionListCrossover : IDecisionListOperator, ICrossover {
+    ILookupParameter<ItemArray<DecisionList>> ParentsParameter { get; }
+    ILookupParameter<DecisionList> ChildParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs	(revision 9334)
@@ -0,0 +1,34 @@
+﻿#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.DecisionList {
+  public interface IDecisionListEvaluator : ISingleObjectiveEvaluator {
+    ILookupParameter<DecisionList> DecisionListParameter { get; }
+    IValueLookupParameter<IntRange> EvaluationPartitionParameter { get; }
+    IValueLookupParameter<PercentValue> RelativeNumberOfEvaluatedSamplesParameter { get; }
+    IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }
+    IValueLookupParameter<IntValue> SizePenaltyMinRulesParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListManipulator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListManipulator.cs	(revision 9334)
@@ -0,0 +1,29 @@
+﻿#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.DecisionList {
+  public interface IDecisionListManipulator : IDecisionListOperator, IManipulator {
+    ILookupParameter<DecisionList> ChildParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListOperator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListOperator.cs	(revision 9334)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IDecisionListOperator : IOperator {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListSolution.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListSolution.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListSolution.cs	(revision 9334)
@@ -0,0 +1,38 @@
+﻿#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;
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IDecisionListSolution {
+    DecisionList Model { get; }
+    IDecisionListClassificationProblemData ProblemData { get; set; }
+
+    event EventHandler ModelChanged;
+    event EventHandler ProblemDataChanged;
+
+    double TrainingAccuracy { get; }
+    double TestAccuracy { get; }
+    int TrainingNumberOfAliveRules { get; }
+    double TrainingTheoryLength { get; }
+    double TrainingExceptionsLength { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Manipulator/UniformOnePointManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Manipulator/UniformOnePointManipulator.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Manipulator/UniformOnePointManipulator.cs	(revision 9334)
@@ -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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList.Mutation {
+  [Item("UniformOnePointMutation", "Description missing")]
+  [StorableClass]
+  public class UniformOnePointManipulator : DecisionListManipulator {
+
+    [StorableConstructor]
+    protected UniformOnePointManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformOnePointManipulator(UniformOnePointManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformOnePointManipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformOnePointManipulator(this, cloner);
+    }
+
+    public static void Apply(IRandom random, DecisionList child, double actionMutationProbability) {
+      int rulePos = random.Next(0, child.Rules.Count);
+      Rule mutateRule = child.Rules[rulePos];
+
+      var possiblePosition = new List<int>() { mutateRule.Action.CurrentPosition };
+      if (child.DefaultAction != null) { possiblePosition.Add(child.DefaultAction.CurrentPosition); }
+      var remainingPositions = mutateRule.Action.GetPossibleActionPositions().Except(possiblePosition);
+
+      if (remainingPositions.Count() > 0 && random.NextDouble() < actionMutationProbability) {
+        int pos = random.Next(0, remainingPositions.Count());
+        mutateRule.Action.SetToPosition(remainingPositions.ElementAt(pos));
+      } else {
+        int attributePos = random.Next(0, mutateRule.Variables.Count);
+        string variableName = mutateRule.Variables.Keys.ToList()[attributePos];
+        mutateRule.Variables[variableName].Mutate(random);
+      }
+    }
+
+    protected override void Manipulate(IRandom random, DecisionList child, double actionMutationProbability) {
+      Apply(random, child, actionMutationProbability);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame	(revision 9334)
@@ -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.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Plugin("HeuristicLab.Encodings.DecisionList", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Encodings.DecisionList-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  public class HeuristicLabEncodingsDecisionListPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs	(revision 9334)
@@ -0,0 +1,56 @@
+﻿#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.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.DecisionList")]
+[assembly: AssemblyDescription("Conjunctive Normal Form encoding")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[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("ca52906b-4905-44b4-b41f-224392ff4d28")]
+
+// 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.9204")]
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
@@ -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.DecisionList")]
+[assembly: AssemblyDescription("Conjunctive Normal Form encoding")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[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("ca52906b-4905-44b4-b41f-224392ff4d28")]
+
+// 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.DecisionList/3.3/Rule.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Rule.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Rule.cs	(revision 9334)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Algorithms.GAssist;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("Rule", "")]
+  public class Rule : Item {
+    [Storable]
+    private IDictionary<string, IVariable> variables;
+    public IDictionary<string, IVariable> Variables {
+      get { return variables; }
+    }
+
+    [Storable]
+    private IAction action;
+    public IAction Action { get { return action; } }
+
+    [StorableConstructor]
+    protected Rule(bool deserializing) : base(deserializing) { }
+    protected Rule(Rule original, Cloner cloner)
+      : base(original, cloner) {
+      variables = new Dictionary<string, IVariable>(original.variables.Count);
+      foreach (var item in original.variables) {
+        variables.Add(item.Key, cloner.Clone(item.Value));
+      }
+      action = (IAction)original.action.Clone();
+    }
+    public Rule()
+      : base() {
+      variables = new Dictionary<string, IVariable>();
+    }
+    public Rule(IEnumerable<IVariable> condition, IAction action)
+      : this() {
+      foreach (var variable in condition) {
+        variables.Add(variable.VariableName, variable);
+      }
+      this.action = action;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Rule(this, cloner);
+    }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      foreach (var variable in Variables) {
+        sb.Append(variable.Value + "|");
+      }
+      sb.Append(Action);
+      return sb.ToString();
+    }
+
+    public void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> discretizer) {
+      foreach (var variable in variables.Values) {
+        variable.Randomize(random, onePercentage, discretizer);
+      }
+      action.Randomize(random);
+    }
+
+    public double ComputeTheoryLength() {
+      return variables.Sum(x => x.Value.ComputeTheoryLength());
+    }
+
+    public bool MatchInput(DecisionListInput target) {
+      foreach (var variable in variables) {
+        if (!target.InputDictionary.ContainsKey(variable.Key)) { throw new ArgumentException("Input doesn't contain variable"); }
+        if (!variable.Value.Match(target.InputDictionary[variable.Key])) { return false; }
+      }
+      return true;
+    }
+
+    public Rule Crossover(Rule rule, IRandom random) {
+      //variables and rule.Variables have to be the same
+      int cutpoint = random.Next(0, Variables.Count);
+      var crossedVariables = new List<IVariable>(variables.Count);
+      var variableNames = variables.Keys.ToList();
+      for (int i = 0; i < cutpoint; i++) {
+        crossedVariables.Add(this.Variables[variableNames[i]]);
+      }
+      for (int i = cutpoint; i < variables.Count; i++) {
+        crossedVariables.Add(rule.Variables[variableNames[i]]);
+      }
+      IAction action = random.Next(0, 2) == 0 ? this.action : rule.action;
+      return new Rule(crossedVariables, action);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs	(revision 9334)
@@ -0,0 +1,193 @@
+﻿#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.Algorithms.GAssist;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("DoubleVariable", "")]
+  public class DoubleVariable : Variable<double> {
+
+    [Storable]
+    private IDiscretizer discretizer;
+
+    [Storable]
+    private IList<int> curIntervals;
+
+    [Storable]
+    private int maxIntervals;
+
+    [StorableConstructor]
+    protected DoubleVariable(bool deserializing) : base(deserializing) { }
+    protected DoubleVariable(DoubleVariable original, Cloner cloner)
+      : base(original, cloner) {
+      discretizer = (IDiscretizer)original.discretizer.Clone();
+      curIntervals = new List<int>(original.curIntervals);
+      maxIntervals = original.maxIntervals;
+    }
+    public DoubleVariable(string variableName, int maxIntervals)
+      : base(variableName) {
+      this.maxIntervals = maxIntervals;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoubleVariable(this, cloner);
+    }
+
+    public override void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> discretizers) {
+      discretizer = discretizers.ElementAt(random.Next(0, discretizers.Count()));
+      int microIntervals = discretizer.NumberOfMicroIntervals(variableName);
+      int maxAllowedIntervals = Math.Min(maxIntervals, microIntervals);
+      int numberOfIntervals = 2;
+      if (maxAllowedIntervals > 2) {
+        numberOfIntervals = random.Next(2, maxAllowedIntervals);
+      }
+
+      attributes = new List<bool>(numberOfIntervals);
+      var curIntervals = new List<int>(numberOfIntervals);
+
+      for (int i = 0; i < numberOfIntervals - 1; i++) {
+        int microInt = random.Next(1, microIntervals - (numberOfIntervals - i - 1));
+        microIntervals -= microInt;
+        curIntervals.Add(microInt);
+        attributes[i] = random.NextDouble() < onePercentage;
+      }
+      // add last interval
+      curIntervals.Add(microIntervals);
+      attributes[numberOfIntervals - 1] = random.NextDouble() < onePercentage;
+    }
+
+    public override double ComputeTheoryLength() {
+      int intervalCount = 0;
+      bool curSet = attributes.First();
+      // first interval started
+      if (curSet) {
+        intervalCount++;
+      }
+      foreach (var attribute in attributes) {
+        if (curSet != attribute) {
+          intervalCount++;
+          curSet = attribute;
+        }
+      }
+      // if the last last interval is not set
+      if (!curSet) {
+        intervalCount--;
+      }
+      return intervalCount;
+    }
+
+    public override bool Match(string input) {
+      return Match(double.Parse(input));
+    }
+
+    public bool Match(double input) {
+      var realCutpoints = GetValuesToCutPoints(discretizer.GetCutPoints(variableName), curIntervals);
+      int pos = 0;
+      while (input >= realCutpoints[pos]) {
+        pos++;
+      }
+      return attributes[pos];
+    }
+
+    private IList<double> GetValuesToCutPoints(IEnumerable<double> cutpoints, IEnumerable<int> microIntervals) {
+      var intervalValues = new List<double>();
+      var cutpointList = cutpoints.ToList();
+      int cur = 0;
+      foreach (var microInterval in microIntervals) {
+        cur += microInterval;
+        intervalValues.Add(cutpointList[cur]);
+      }
+      return intervalValues;
+    }
+
+    public override void Split(IRandom random) {
+      // cannot create more than maximal allowed intervals
+      if (curIntervals.Count >= maxIntervals) { return; }
+      int selectedInterval = random.Next(0, curIntervals.Count);
+      // a single microinterval cannot be split
+      if (curIntervals[selectedInterval] <= 1) { return; }
+
+      // split interval
+      int splitPart1 = random.Next(1, curIntervals[selectedInterval]);
+      int splitPart2 = curIntervals[selectedInterval] - splitPart1;
+
+      // resize old interval
+      curIntervals[selectedInterval] = splitPart1;
+      // insert new interval at correct position
+      curIntervals.Insert(selectedInterval + 1, splitPart2);
+
+      // set new interval to the same bool value as old one
+      attributes.Insert(selectedInterval + 1, attributes[selectedInterval]);
+      return;
+    }
+
+    public override void Merge(IRandom random) {
+      // cannot merge a single interval
+      if (curIntervals.Count == 1) { return; }
+      int selectedInterval = random.Next(0, curIntervals.Count);
+      int neighbour;
+      //if selected interval is the leftmost one, the neighbour on the right side is used
+      if (selectedInterval == 0) {
+        neighbour = selectedInterval + 1;
+        //if the selected interval is the rightmost, the neighbour on the left side is used
+      } else if (selectedInterval == curIntervals.Count - 1) {
+        neighbour = selectedInterval - 1;
+      } else {
+        if (random.Next() < 0.5) {
+          neighbour = selectedInterval - 1;
+        } else {
+          neighbour = selectedInterval + 1;
+        }
+      }
+
+      bool value;
+      if (curIntervals[selectedInterval] > curIntervals[neighbour]) {
+        value = attributes[selectedInterval];
+      } else if (curIntervals[selectedInterval] < curIntervals[neighbour]) {
+        value = attributes[neighbour];
+      } else {
+        if (random.Next() < 0.5) {
+          value = attributes[selectedInterval];
+        } else {
+          value = attributes[neighbour];
+        }
+      }
+
+      curIntervals[selectedInterval] += curIntervals[neighbour];
+      curIntervals.RemoveAt(neighbour);
+
+      attributes[selectedInterval] = value;
+      attributes.RemoveAt(neighbour);
+      return;
+    }
+
+    public override void Reinitialize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> descretizers) {
+      Randomize(random, onePercentage, descretizers);
+      return;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs	(revision 9334)
@@ -0,0 +1,46 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Algorithms.GAssist;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  public interface IVariable : IItem {
+    string VariableName { get; }
+    Type VariableType { get; }
+
+    void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> descretizers);
+
+    double ComputeTheoryLength();
+
+    bool Match(string input);
+
+    void Mutate(IRandom random);
+
+    void Merge(IRandom Random);
+
+    void Reinitialize(IRandom Random, double onePercentage, IEnumerable<IDiscretizer> descretizers);
+
+    void Split(IRandom Random);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs	(revision 9334)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("IntVariable", "")]
+  public class IntVariable : Variable<int> {
+
+    [Storable]
+    protected IList<int> possibleFeatures;
+    public IEnumerable<int> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [StorableConstructor]
+    protected IntVariable(bool deserializing) : base(deserializing) { }
+    protected IntVariable(IntVariable original, Cloner cloner)
+      : base(original, cloner) {
+      this.possibleFeatures = new List<int>(original.possibleFeatures);
+    }
+    public IntVariable() : base() { }
+    public IntVariable(string variableName, IList<int> variableValues)
+      : base(variableName) {
+      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
+      }
+      possibleFeatures = variableValues;
+      attributes = Enumerable.Repeat<bool>(true, possibleFeatures.Count).ToList();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntVariable(this, cloner);
+    }
+
+    public override double ComputeTheoryLength() {
+      return attributes.Count + attributes.Count(x => x == false);
+    }
+
+    public override bool Match(string input) {
+      return Match(int.Parse(input));
+    }
+
+    public bool Match(int input) {
+      return attributes[possibleFeatures.IndexOf(input)];
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs	(revision 9334)
@@ -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;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("StringVariable", "")]
+  public class StringVariable : Variable<string> {
+
+    [Storable]
+    protected IList<string> possibleFeatures;
+    public IEnumerable<string> PossibleFeatures {
+      get { return possibleFeatures; }
+    }
+
+    [StorableConstructor]
+    protected StringVariable(bool deserializing) : base(deserializing) { }
+    protected StringVariable(StringVariable original, Cloner cloner)
+      : base(original, cloner) {
+      possibleFeatures = new List<string>(original.possibleFeatures);
+    }
+    public StringVariable() : base() { }
+    public StringVariable(string variableName, IList<string> variableValues)
+      : base(variableName) {
+      if (variableValues.Count() > 0 && variableValues.Count() != variableValues.Distinct().Count()) {
+        throw new ArgumentException("variableValues have to be distinct and there has to be at least one value.");
+      }
+      possibleFeatures = variableValues;
+      attributes = Enumerable.Repeat<bool>(true, possibleFeatures.Count).ToList();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StringVariable(this, cloner);
+    }
+
+    public override double ComputeTheoryLength() {
+      return attributes.Count + attributes.Count(x => x == false);
+    }
+
+    public override bool Match(string input) {
+      return attributes[possibleFeatures.IndexOf(input)];
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs	(revision 9334)
@@ -0,0 +1,97 @@
+﻿#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.Text;
+using HeuristicLab.Algorithms.GAssist;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [StorableClass]
+  [Item("Variable", "")]
+  public abstract class Variable<T> : Item, IVariable {
+    [Storable]
+    protected IList<bool> attributes;
+    public IEnumerable<bool> Attributes {
+      get { return attributes; }
+    }
+
+    [Storable]
+    protected string variableName;
+    public string VariableName {
+      get { return variableName; }
+    }
+
+    public Type VariableType { get { return typeof(T); } }
+
+    [StorableConstructor]
+    protected Variable(bool deserializing) : base(deserializing) { }
+    protected Variable(Variable<T> original, Cloner cloner)
+      : base(original, cloner) {
+      variableName = original.variableName;
+      attributes = new List<bool>(original.attributes);
+    }
+    public Variable()
+      : base() {
+      attributes = new List<bool>();
+    }
+    public Variable(string variableName)
+      : base() {
+      this.variableName = variableName;
+      attributes = new List<bool>();
+    }
+
+    public virtual void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> descretizers) {
+      for (int i = 0; i < attributes.Count; i++) {
+        attributes[i] = random.NextDouble() < onePercentage;
+      }
+    }
+
+    public abstract double ComputeTheoryLength();
+    public abstract bool Match(string input);
+
+    public virtual string ToFullString() { throw new NotImplementedException(); }
+
+    public override string ToString() {
+      StringBuilder sb = new StringBuilder();
+      foreach (var attr in attributes) {
+        if (attr) {
+          sb.Append('1');
+        } else {
+          sb.Append('0');
+        }
+      }
+      return sb.ToString();
+    }
+
+    public void Mutate(IRandom random) {
+      int pos = random.Next(0, attributes.Count);
+      attributes[pos] = !attributes[pos];
+    }
+
+    public virtual void Merge(IRandom Random) { return; }
+    public virtual void Reinitialize(IRandom Random, double onePercentage, IEnumerable<IDiscretizer> descretizers) { return; }
+    public virtual void Split(IRandom Random) { return; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3.csproj	(revision 9333)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3.csproj	(revision 9334)
@@ -79,4 +79,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblem.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblem.cs	(revision 9334)
@@ -0,0 +1,118 @@
+﻿#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.DecisionList;
+using HeuristicLab.Encodings.DecisionList.Interfaces;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.DecisionListClassification {
+  [Item("DecisionListClassificationProblem", "")]
+  [StorableClass]
+  [Creatable("Problems")]
+  public class DecisionListClassificationProblem : HeuristicOptimizationProblem<IDecisionListEvaluator, IDecisionListCreator>, IDecisionListClassificationProblem {
+
+    #region parameter properties
+    public IFixedValueParameter<BoolValue> MaximizationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.MaximizationParameter {
+      get { return MaximizationParameter; }
+    }
+    public IFixedValueParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    IParameter ISingleObjectiveHeuristicOptimizationProblem.BestKnownQualityParameter {
+      get { return BestKnownQualityParameter; }
+    }
+    public IValueParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
+      get { return (IValueParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+    public IFixedValueParameter<IntValue> SizePenaltyMinRulesParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["SizePenaltyMinRules"]; }
+    }
+    public IFixedValueParameter<IntValue> ActivationIterationParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["ActivationIteration"]; }
+    }
+    public IFixedValueParameter<DoubleValue> InitialTheoryLengthRatioParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialTheoryLengthRatio"]; }
+    }
+    public IFixedValueParameter<DoubleValue> WeightRelaxFactorParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["WeightRelaxFactor"]; }
+    }
+
+    public IDecisionListClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.Value; }
+      protected set {
+        ProblemDataParameter.Value = value;
+      }
+    }
+    IParameter IDecisionListClassificationProblem.ProblemDataParameter {
+      get { return ProblemDataParameter; }
+    }
+    IDecisionListClassificationProblemData IDecisionListClassificationProblem.ProblemData {
+      get { return ProblemData; }
+    }
+
+    IDecisionListEvaluator IDecisionListClassificationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    ISingleObjectiveEvaluator ISingleObjectiveHeuristicOptimizationProblem.Evaluator {
+      get { return Evaluator; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListClassificationProblem(bool deserializing) : base(deserializing) { }
+    protected DecisionListClassificationProblem(DecisionListClassificationProblem original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public DecisionListClassificationProblem()
+      : this(new DecisionListClassificationProblemData(new Dataset(DecisionListClassificationProblemData.defaultVariableNames, DecisionListClassificationProblemData.defaultData),
+        DecisionListClassificationProblemData.defaultVariableNames.Take(DecisionListClassificationProblemData.defaultVariableNames.Length - 1), DecisionListClassificationProblemData.defaultVariableNames.Last()),
+        new MDLEvaluator(), new UniformRandomDecisionListCreator()) { }
+
+    public DecisionListClassificationProblem(IDecisionListClassificationProblemData problemData, IDecisionListEvaluator decisionlistEvaluator, IDecisionListCreator decisionListCreator)
+      : base(decisionlistEvaluator, decisionListCreator) {
+      Parameters.Add(new ValueParameter<IDecisionListClassificationProblemData>("ProblemData", "", problemData));
+      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "", new BoolValue(true)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("BestKnownQuality", "", new DoubleValue(0.5)));
+      Parameters.Add(new FixedValueParameter<IntValue>("SizePenaltyMinRules", "", new IntValue(4)));
+      Parameters.Add(new FixedValueParameter<IntValue>("ActivationIteration", "", new IntValue(25)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("InitialTheoryLengthRatio", "", new DoubleValue(0.075)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("WeightRelaxFactor", "", new DoubleValue(0.9)));
+
+      Evaluator.SizePenaltyMinRulesParameter.ActualName = "SizePenaltyMinRules";
+      // do differently
+      ((MDLEvaluator)Evaluator).MDLCalculatorParameter.Value = new MDLCalculator(ActivationIterationParameter.Value.Value, InitialTheoryLengthRatioParameter.Value.Value, WeightRelaxFactorParameter.Value.Value);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecisionListClassificationProblem(this, cloner);
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblemData.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/DecisionListClassificationProblemData.cs	(revision 9334)
@@ -0,0 +1,244 @@
+﻿#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.DecisionList;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.DecisionListClassification {
+  [StorableClass]
+  [Item("DecisionListClassificationProblemData", "")]
+  public class DecisionListClassificationProblemData : ParameterizedNamedItem, IDecisionListClassificationProblemData {
+
+    #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,1},
+      {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 IConstrainedValueParameter<StringValue> TargetVariableParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters["TargetVariable"]; }
+    }
+    public IFixedValueParameter<IntRange> TrainingPartitionParameter {
+      get { return (IFixedValueParameter<IntRange>)Parameters["TrainingPartition"]; }
+    }
+    public IFixedValueParameter<IntRange> TestPartitionParameter {
+      get { return (IFixedValueParameter<IntRange>)Parameters["TestPartition"]; }
+    }
+    public IFixedValueParameter<Rule> SampleRuleParameter {
+      get { return (IFixedValueParameter<Rule>)Parameters["SampleRule"]; }
+    }
+    public IFixedValueParameter<IntValue> MaxIntervalsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["MaxIntervals"]; }
+    }
+    #endregion
+
+    #region properties
+    public Dataset Dataset {
+      get { return DatasetParameter.Value; }
+    }
+    public ICheckedItemList<StringValue> ConditionVariables {
+      get { return ConditionVariablesParameter.Value; }
+    }
+    public StringValue TargetVariable {
+      get { return TargetVariableParameter.Value; }
+    }
+    public IEnumerable<string> AllowedConditionVariables {
+      get { return ConditionVariables.CheckedItems.Select(x => x.Value.Value); }
+    }
+    //public IEnumerable<string> AllowedTargetVariables {
+    //  get { return ActionVariables.CheckedItems.Select(x => x.Value.Value); }
+    //}
+    public IntRange TrainingPartition {
+      get { return TrainingPartitionParameter.Value; }
+    }
+    public IntRange TestPartition {
+      get { return TestPartitionParameter.Value; }
+    }
+    public IEnumerable<int> TrainingIndices {
+      get {
+        return Enumerable.Range(TrainingPartition.Start, Math.Max(0, TrainingPartition.End - TrainingPartition.Start))
+                         .Where(IsTrainingSample);
+      }
+    }
+    public IEnumerable<int> TestIndices {
+      get {
+        return Enumerable.Range(TestPartition.Start, Math.Max(0, TestPartition.End - TestPartition.Start))
+           .Where(IsTestSample);
+      }
+    }
+    public bool IsTrainingSample(int index) {
+      return index >= 0 && index < Dataset.Rows &&
+        TrainingPartition.Start <= index && index < TrainingPartition.End &&
+        (index < TestPartition.Start || TestPartition.End <= index);
+    }
+    public bool IsTestSample(int index) {
+      return index >= 0 && index < Dataset.Rows &&
+             TestPartition.Start <= index && index < TestPartition.End;
+    }
+    public int Classes {
+      get { return SampleRuleParameter.Value.Action.Possibilities; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DecisionListClassificationProblemData(bool deserializing) : base(deserializing) { }
+    protected DecisionListClassificationProblemData(DecisionListClassificationProblemData original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DecisionListClassificationProblemData(Dataset dataset, IEnumerable<string> allowedConditionVariables, string targetVariable) {
+      if (dataset == null) throw new ArgumentNullException("The dataset must not be null.");
+      if (allowedConditionVariables == null) throw new ArgumentNullException("The allowedActionVariables must not be null.");
+
+      if (allowedConditionVariables.Except(dataset.DoubleVariables).Any())
+        throw new ArgumentException("All allowed condition variables must be present in the dataset and of type double.");
+
+      //var validTargetVariableValues = CheckVariablesForPossibleTargetVariables(dataset).Select(x => new StringValue(x).AsReadOnly()).ToList();
+      var validTargetVariableValues = dataset.VariableNames.Select(x => new StringValue(x));
+      var target = validTargetVariableValues.Where(x => x.Value == targetVariable).DefaultIfEmpty(validTargetVariableValues.First()).First();
+
+      var conditionVariables = new CheckedItemList<StringValue>(dataset.DoubleVariables.Select(x => new StringValue(x)));
+      foreach (StringValue x in conditionVariables) {
+        conditionVariables.SetItemCheckedState(x, allowedConditionVariables.Contains(x.Value));
+      }
+
+      int trainingPartitionStart = 0;
+      int trainingPartitionEnd = dataset.Rows / 2;
+      int testPartitionStart = dataset.Rows / 2;
+      int testPartitionEnd = dataset.Rows;
+
+      Parameters.Add(new FixedValueParameter<Dataset>("Dataset", "", dataset));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable", new ItemSet<StringValue>(validTargetVariableValues), target));
+      Parameters.Add(new FixedValueParameter<ReadOnlyCheckedItemList<StringValue>>("ConditionVariables", "", conditionVariables.AsReadOnly()));
+      Parameters.Add(new FixedValueParameter<IntRange>("TrainingPartition", "", new IntRange(trainingPartitionStart, trainingPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<IntRange>("TestPartition", "", new IntRange(testPartitionStart, testPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<IntValue>("MaxIntervals", "", new IntValue(5)));
+      Parameters.Add(new FixedValueParameter<Rule>("SampleRule", "", CreateSampleRule(dataset, conditionVariables.CheckedItems.Select(x => x.Value.Value), target.Value)));
+
+      ((ValueParameter<Dataset>)DatasetParameter).ReactOnValueToStringChangedAndValueItemImageChanged = false;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DecisionListClassificationProblemData(this, cloner);
+    }
+
+    private Rule CreateSampleRule(Dataset dataset, IEnumerable<string> conditionVariables, string target) {
+      IEnumerable<HeuristicLab.Encodings.DecisionList.IVariable> condition = GetConditionOfDataSet(dataset, conditionVariables);
+      IAction action = GetActionOfDataset(dataset, target);
+      return new Rule(condition, action);
+    }
+
+    private IAction GetActionOfDataset(DataAnalysis.Dataset dataset, string target) {
+      IAction action = null;
+      var variableValues = dataset.GetValues(target);
+      if (variableValues is List<string>) {
+        action = new StringAction(target, (variableValues as List<string>).Distinct().ToList());
+      } else if (variableValues is List<double>) {
+        var doubleValues = (variableValues as List<double>).Distinct();
+        if (doubleValues.All(x => x % 1 == 0)) {
+          action = new IntAction(target, doubleValues.Select(x => Convert.ToInt32(x)).ToList());
+        } else {
+          throw new ArgumentException("The target variable contains double values. Therefore it can't be used as target");
+        }
+      } else {
+        throw new ArgumentException("There is no matching variable type for the values in the dataset");
+      }
+      return action;
+    }
+
+    private IEnumerable<Encodings.DecisionList.IVariable> GetConditionOfDataSet(DataAnalysis.Dataset dataset, IEnumerable<string> conditionVariables) {
+      var condition = new List<HeuristicLab.Encodings.DecisionList.IVariable>();
+      foreach (var variableName in conditionVariables) {
+        var variableValues = dataset.GetValues(variableName);
+        HeuristicLab.Encodings.DecisionList.IVariable variable;
+        if (variableValues is List<string>) {
+          variable = new StringVariable(variableName, (variableValues as List<string>).Distinct().ToList());
+        } else if (variableValues is List<double>) {
+          var doubleValues = (variableValues as List<double>).Distinct();
+          if (doubleValues.All(x => x % 1 == 0)) {
+            // ToList call is necessary, because otherwise it wouldn't be possible to serialize it
+            variable = new IntVariable(variableName, doubleValues.Select(x => Convert.ToInt32(x)).ToList());
+          } else {
+            variable = new DoubleVariable(variableName, MaxIntervalsParameter.Value.Value);
+          }
+        } else {
+          throw new ArgumentException("There is no matching variable type for the values in the dataset");
+        }
+        condition.Add(variable);
+      }
+      return condition;
+    }
+
+    public IEnumerable<DecisionListInput> FetchInput(IEnumerable<int> rows) {
+      foreach (var row in rows) {
+        yield return FetchInput(row);
+      }
+    }
+
+    protected IDictionary<int, DecisionListInput> fetchInputCache = new Dictionary<int, DecisionListInput>();
+    public DecisionListInput FetchInput(int row) {
+      if (!fetchInputCache.ContainsKey(row)) {
+        DecisionListInput input = new DecisionListInput();
+        var variableNames = SampleRuleParameter.Value.Variables.Keys.ToList();
+        variableNames.Add(SampleRuleParameter.Value.Action.VariableName);
+        foreach (var variableName in variableNames) {
+          input.InputDictionary.Add(variableName, Dataset.GetValue(row, variableName));
+        }
+        fetchInputCache.Add(row, input);
+      }
+      return fetchInputCache[row];
+    }
+
+    public IEnumerable<IAction> FetchAction(IEnumerable<int> rows) {
+      foreach (var row in rows) {
+        yield return FetchAction(row);
+      }
+    }
+    protected IDictionary<int, IAction> fetchActionCache = new Dictionary<int, IAction>();
+    public IAction FetchAction(int row) {
+      if (!fetchActionCache.ContainsKey(row)) {
+        var action = (IAction)SampleRuleParameter.Value.Action.Clone();
+        action.SetTo(Dataset.GetValue(row, action.VariableName));
+        fetchActionCache.Add(row, action);
+      }
+      return fetchActionCache[row];
+    }
+
+    public event EventHandler Changed;
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/HeuristicLab.Problems.DecisionListClassification-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/HeuristicLab.Problems.DecisionListClassification-3.3.csproj	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/HeuristicLab.Problems.DecisionListClassification-3.3.csproj	(revision 9334)
@@ -0,0 +1,124 @@
+﻿<?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>{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Problems.DecisionListClassification</RootNamespace>
+    <AssemblyName>HeuristicLab.Problems.DecisionListClassification-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>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3">
+      <HintPath>..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="DecisionListClassificationProblem.cs" />
+    <Compile Include="DecisionListClassificationProblemData.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Algorithms.GAssist\3.3\HeuristicLab.Algorithms.GAssist-3.3.csproj">
+      <Project>{f191a6fa-1b3c-4f82-a711-873b4d839bc0}</Project>
+      <Name>HeuristicLab.Algorithms.GAssist-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.DecisionList\3.3\HeuristicLab.Encodings.DecisionList-3.3.csproj">
+      <Project>{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}</Project>
+      <Name>HeuristicLab.Encodings.DecisionList-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
+      <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis-3.4</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.DecisionListClassification/3.3/Plugin.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Plugin.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Plugin.cs.frame	(revision 9334)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Problems.DecisionListClassification {
+  [Plugin("HeuristicLab.Problems.DecisionListClassification", "3.3.7.$WCREV$")]
+  [PluginFile("HeuristicLab.Problems.DecisionListClassification-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  public class HeuristicLabProblemsDecisionListClassificationPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs	(revision 9334)
@@ -0,0 +1,56 @@
+﻿#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.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.DecisionListClassification")]
+[assembly: AssemblyDescription("")]
+[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("ad5e20a2-4e79-4c62-b043-4089069ff2db")]
+
+// 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.9228")]
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.DecisionListClassification/3.3/Properties/AssemblyInfo.cs.frame	(revision 9334)
@@ -0,0 +1,56 @@
+﻿#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.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.DecisionListClassification")]
+[assembly: AssemblyDescription("")]
+[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("ad5e20a2-4e79-4c62-b043-4089069ff2db")]
+
+// 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.VariableVectorClassification/3.3/HeuristicLab.Problems.VariableVectorClassification-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/HeuristicLab.Problems.VariableVectorClassification-3.3.csproj	(revision 9333)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/HeuristicLab.Problems.VariableVectorClassification-3.3.csproj	(revision 9334)
@@ -76,4 +76,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
Index: /branches/LearningClassifierSystems/LearningClassifierSystem.sln
===================================================================
--- /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9333)
+++ /branches/LearningClassifierSystems/LearningClassifierSystem.sln	(revision 9334)
@@ -29,4 +29,10 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.DataAnalysis-3.4", "HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj", "{DF87C13E-A889-46FF-8153-66DCAA8C5674}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.GAssist-3.3", "HeuristicLab.Algorithms.GAssist\3.3\HeuristicLab.Algorithms.GAssist-3.3.csproj", "{F191A6FA-1B3C-4F82-A711-873B4D839BC0}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.DecisionList-3.3", "HeuristicLab.Encodings.DecisionList\3.3\HeuristicLab.Encodings.DecisionList-3.3.csproj", "{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.DecisionListClassification-3.3", "HeuristicLab.Problems.DecisionListClassification\3.3\HeuristicLab.Problems.DecisionListClassification-3.3.csproj", "{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}"
 EndProject
 Global
@@ -140,4 +146,28 @@
 		{DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x86.ActiveCfg = Release|x86
 		{DF87C13E-A889-46FF-8153-66DCAA8C5674}.Release|x86.Build.0 = Release|x86
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Release|x64.ActiveCfg = Release|Any CPU
+		{F191A6FA-1B3C-4F82-A711-873B4D839BC0}.Release|x86.ActiveCfg = Release|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Release|x64.ActiveCfg = Release|Any CPU
+		{86912E6B-4EF3-4B37-809B-5A7C4A28D0C9}.Release|x86.ActiveCfg = Release|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Release|x64.ActiveCfg = Release|Any CPU
+		{CA20AC55-B57D-4078-8CB9-C44E5FF7958B}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
