Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IAction.cs	(revision 9605)
@@ -34,4 +34,5 @@
     bool Match(IAction action);
     void SetTo(string value);
+    void SetTo(IGAssistNiche action);
 
     IEnumerable<int> GetPossibleActionPositions();
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/IntAction.cs	(revision 9605)
@@ -117,5 +117,11 @@
 
     public void SetTo(string value) {
-      currentAction = int.Parse(value);
+      SetToPosition(int.Parse(value));
+    }
+
+    public void SetTo(IGAssistNiche action) {
+      var castAction = action as IntAction;
+      if (castAction == null) throw new ArgumentException("action has to be IntAction");
+      SetToPosition(castAction.CurrentAction);
     }
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Action/StringAction.cs	(revision 9605)
@@ -122,5 +122,11 @@
 
     public void SetTo(string value) {
-      currentActionIndex = possibleFeatures.IndexOf(value);
+      SetToPosition(possibleFeatures.IndexOf(value));
+    }
+
+    public void SetTo(IGAssistNiche action) {
+      var castAction = action as StringAction;
+      if (castAction == null) throw new ArgumentException("action has to be IntAction");
+      SetToPosition(castAction.CurrentPosition);
     }
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/SmartDecisionListCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/SmartDecisionListCreator.cs	(revision 9605)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/SmartDecisionListCreator.cs	(revision 9605)
@@ -0,0 +1,83 @@
+﻿#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.Optimization.Operators.LCS;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.DecisionList {
+  [Item("SmartDecisionListCreator", "Description missing")]
+  [StorableClass]
+  public class SmartDecisionListCreator : DecisionListCreator {
+
+    [StorableConstructor]
+    protected SmartDecisionListCreator(bool deserializing) : base(deserializing) { }
+    protected SmartDecisionListCreator(SmartDecisionListCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SmartDecisionListCreator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SmartDecisionListCreator(this, cloner);
+    }
+
+    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers, IAction niche) {
+      var problemData = ProblemDataParameter.ActualValue;
+
+      List<Rule> rules = new List<Rule>();
+      for (int i = 0; i < initialNumberOfRules; i++) {
+        rules.Add(SmartRuleInitialization(problemData, random, sampleRule, initialNumberOfRules, oneProbability, discretizers, niche));
+      }
+      if (niche != null) {
+        return new DecisionList(rules, niche);
+      } else {
+        return new DecisionList(rules);
+      }
+    }
+
+    public static Rule SmartRuleInitialization(IDecisionListClassificationProblemData problemData, IRandom random,
+                                               Rule sampleRule, int initialNumberOfRules, double oneProbability,
+                                               ItemCollection<IDiscretizer> discretizers, IAction niche = null) {
+      IList<int> trainingIndicesOfOtherNiches = null;
+      if (niche != null) {
+        trainingIndicesOfOtherNiches =
+          problemData.TrainingIndices.Where(x => !problemData.FetchAction(x).SameNiche(niche)).ToList();
+      } else {
+        trainingIndicesOfOtherNiches = problemData.TrainingIndices.ToList();
+      }
+
+      var newRule = (Rule)sampleRule.Clone();
+      newRule.Randomize(random, oneProbability, discretizers);
+
+      int sample = random.Next(trainingIndicesOfOtherNiches.Count);
+      var input = problemData.FetchInput(trainingIndicesOfOtherNiches[sample]);
+      var action = problemData.FetchAction(trainingIndicesOfOtherNiches[sample]);
+
+      newRule.SetToMatchInput(input);
+      newRule.Action.SetTo(action);
+      return newRule;
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Creators/UniformRandomDecisionListCreator.cs	(revision 9605)
@@ -43,13 +43,21 @@
     }
 
-    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers) {
+    protected override DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers, IAction niche) {
       List<Rule> rules = new List<Rule>();
       for (int i = 0; i < initialNumberOfRules; i++) {
         var newRule = (Rule)sampleRule.Clone();
-        newRule.Randomize(random, oneProbability, discretizers);
+        if (niche != null) {
+          newRule.Randomize(random, oneProbability, discretizers, new List<IAction>() { niche });
+        } else {
+          newRule.Randomize(random, oneProbability, discretizers);
+        }
         rules.Add(newRule);
       }
 
-      return new DecisionList(rules);
+      if (niche != null) {
+        return new DecisionList(rules, niche);
+      } else {
+        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 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Crossover/SinglePointCrossover.cs	(revision 9605)
@@ -48,5 +48,6 @@
 
     public static DecisionList Apply(IRandom random, DecisionList parent1, DecisionList parent2) {
-      if (!parent1.DefaultAction.Match(parent2.DefaultAction)) { throw new ArgumentException("Default action of parents have to match!"); }
+      if (parent1 == null && parent1 != parent2) { throw new ArgumentException("Either both parents have a default action or none does."); }
+      if (parent1.DefaultAction != null && !parent1.DefaultAction.Match(parent2.DefaultAction)) { throw new ArgumentException("Default action of parents have to match!"); }
 
       int rulesP1 = random.Next(0, parent1.Rules.Count());
@@ -64,4 +65,7 @@
       }
 
+      if (parent1.DefaultAction == null) {
+        return new DecisionList(rules);
+      }
       return new DecisionList(rules, parent1.DefaultAction);
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionList.cs	(revision 9605)
@@ -44,4 +44,8 @@
     }
 
+    public double Length {
+      get { return 1 + rules.Sum(r => r.Length); }
+    }
+
     // default rule (action) is part of the rule set size
     public int RuleSetSize {
@@ -53,5 +57,5 @@
     protected DecisionList(DecisionList original, Cloner cloner)
       : base(original, cloner) {
-      defaultAction = original.DefaultAction;
+      defaultAction = cloner.Clone(original.DefaultAction);
       rules = new List<Rule>(original.rules.Count);
       foreach (var rule in original.Rules) {
@@ -124,19 +128,4 @@
     }
 
-    public void SetNiche(IRandom random, IGAssistNiche niche) {
-      var action = niche as IAction;
-      if (action == null) {
-        throw new ArgumentException("Niche has to be an action");
-      }
-      if (Niche != null) {
-        throw new ArgumentException("Niche has already been set. It cannot be set again.");
-      }
-      defaultAction = action;
-      var except = new List<IAction>() { action };
-      foreach (var rule in rules.Where(x => x.Action.SameNiche(niche))) {
-        rule.Action.Randomize(random, except);
-      }
-    }
-
     public void ApplySplit(IRandom random, double probability) {
       foreach (var rule in rules) {
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListCreator.cs	(revision 9605)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -52,4 +53,7 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
+    public ILookupParameter<IGAssistNiche> GAssistNicheParameter {
+      get { return (ILookupParameter<IGAssistNiche>)Parameters["GAssistNiche"]; }
+    }
     #endregion
 
@@ -67,13 +71,19 @@
       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."));
-      Parameters.Add(new ValueLookupParameter<IAction>("DefaultAction", ""));
+      Parameters.Add(new LookupParameter<IGAssistNiche>("GAssistNiche", ""));
     }
 
     public override IOperation Apply() {
-      DecisionListParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemDataParameter.ActualValue.SampleRuleParameter.Value, InitialNumberOfRulesParameter.ActualValue.Value, OneProbabilityParameter.ActualValue.Value, DiscretizersParameter.ActualValue);
+      if (GAssistNicheParameter.ActualValue != null && !(GAssistNicheParameter.ActualValue is IAction)) throw new ArgumentException("GAssistNiche has to be a IAction.");
+      DecisionListParameter.ActualValue = Create(RandomParameter.ActualValue,
+                                              ProblemDataParameter.ActualValue.SampleRuleParameter.Value,
+                                              InitialNumberOfRulesParameter.ActualValue.Value,
+                                              OneProbabilityParameter.ActualValue.Value,
+                                              DiscretizersParameter.ActualValue,
+                                              (IAction)GAssistNicheParameter.ActualValue);
       return base.Apply();
     }
 
-    protected abstract DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers);
+    protected abstract DecisionList Create(IRandom random, Rule sampleRule, int initialNumberOfRules, double oneProbability, ItemCollection<IDiscretizer> discretizers, IAction niche);
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9605)
@@ -49,8 +49,14 @@
       get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
+    public ILookupParameter<DoubleValue> LengthParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Length"]; }
+    }
     public IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter {
       get { return (IValueLookupParameter<IDecisionListClassificationProblemData>)Parameters["ProblemData"]; }
     }
 
+    public IValueLookupParameter<BoolValue> UseMDLParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["UseMDL"]; }
+    }
     public ILookupParameter<MDLCalculator> MDLCalculatorParameter {
       get { return (ILookupParameter<MDLCalculator>)Parameters["MDLCalculator"]; }
@@ -73,4 +79,7 @@
       get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters["Strata"]; }
     }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
     #endregion
 
@@ -90,5 +99,7 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("SizePenaltyMinRules", ""));
       Parameters.Add(new LookupParameter<DoubleValue>("Quality", ""));
+      Parameters.Add(new LookupParameter<DoubleValue>("Length", ""));
       Parameters.Add(new ValueLookupParameter<IDecisionListClassificationProblemData>("ProblemData", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("UseMDL", "", new BoolValue(true)));
       Parameters.Add(new LookupParameter<MDLCalculator>("MDLCalculator", ""));
       Parameters.Add(new LookupParameter<IntValue>("Iterations", ""));
@@ -97,4 +108,11 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("RuleDeletionMinRules", "", new IntValue(12)));
       Parameters.Add(new ValueLookupParameter<ItemList<ItemList<IntValue>>>("Strata", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "", new BoolValue(false)));
+
+      UseMDLParameter.Value.ValueChanged += UseMDLParameter_ValueChanged;
+    }
+
+    private void UseMDLParameter_ValueChanged(object sender, System.EventArgs e) {
+      MaximizationParameter.Value.Value = !UseMDLParameter.Value.Value;
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -103,6 +121,4 @@
 
     public override IOperation Apply() {
-      double penalty = 1;
-
       var strata = StrataParameter.ActualValue;
       int iteration = IterationsParameter.ActualValue.Value;
@@ -125,4 +141,5 @@
       var estimated = dl.Evaluate(input, out aliveRules, out theoryLength);
 
+      double penalty = 1;
       if (aliveRules.Count < SizePenaltyMinRulesParameter.ActualValue.Value) {
         penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - aliveRules.Count));
@@ -132,5 +149,10 @@
 
       double accuracy = DecisionListSolution.CalculateAccuracy(actions, estimated);
-      QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
+      if (UseMDLParameter.ActualValue.Value) {
+        QualityParameter.ActualValue =
+          new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
+      } else {
+        QualityParameter.ActualValue = new DoubleValue(accuracy * accuracy * penalty);
+      }
 
       if (iteration >= IterationRuleDeletionParameter.ActualValue.Value) {
@@ -141,4 +163,6 @@
         }
       }
+
+      LengthParameter.ActualValue = new DoubleValue(dl.Length * aliveRules.Count / dl.RuleSetSize);
       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 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/HeuristicLab.Encodings.DecisionList-3.3.csproj	(revision 9605)
@@ -93,4 +93,5 @@
     <Compile Include="Action\IntAction.cs" />
     <Compile Include="Analyzer\BestTrainingDecisionListAnalyzer.cs" />
+    <Compile Include="Creators\SmartDecisionListCreator.cs" />
     <Compile Include="Creators\UniformRandomDecisionListCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListCreator.cs	(revision 9605)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Encodings.DecisionList {
-  public interface IDecisionListCreator : IDecisionListOperator, ISolutionCreator, IStochasticOperator, IGAssistIndividualCreator {
+  public interface IDecisionListCreator : IDecisionListOperator, ISolutionCreator, IStochasticOperator, IGAssistSolutionCreator {
     IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }
     ILookupParameter<DecisionList> DecisionListParameter { get; }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Interfaces/IDecisionListEvaluator.cs	(revision 9605)
@@ -25,5 +25,5 @@
 
 namespace HeuristicLab.Encodings.DecisionList {
-  public interface IDecisionListEvaluator : IStrataSingleObjectiveEvaluator {
+  public interface IDecisionListEvaluator : IGAssistObjectiveEvaluator {
     ILookupParameter<DecisionList> DecisionListParameter { get; }
     IValueLookupParameter<IDecisionListClassificationProblemData> ProblemDataParameter { get; }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Plugin.cs.frame	(revision 9605)
@@ -27,6 +27,12 @@
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
-  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators.LCS", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
   [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.DataAnalysis", "3.4")]
   public class HeuristicLabEncodingsDecisionListPlugin : PluginBase {
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Rule.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Rule.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Rule.cs	(revision 9605)
@@ -43,4 +43,8 @@
     public IAction Action { get { return action; } }
 
+    public double Length {
+      get { return variables.Values.Sum(x => x.Length); }
+    }
+
     [StorableConstructor]
     protected Rule(bool deserializing) : base(deserializing) { }
@@ -77,9 +81,22 @@
     }
 
-    public void Randomize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> discretizer) {
+    public void Randomize(IRandom random, double oneProbability, IEnumerable<IDiscretizer> discretizers, IEnumerable<IAction> exceptActions = null) {
       foreach (var variable in variables.Values) {
-        variable.Randomize(random, onePercentage, discretizer);
+        variable.Randomize(random, oneProbability, discretizers);
       }
-      action.Randomize(random);
+      if (exceptActions == null) {
+        action.Randomize(random);
+      } else {
+        action.Randomize(random, exceptActions);
+      }
+    }
+
+    public void SetToMatchInput(IGAssistInput input) {
+      foreach (var variable in variables) {
+        if (!input.VariableNames.Contains(variable.Key)) {
+          throw new ArgumentException("input does not contain variable name of rule");
+        }
+        variable.Value.SetToMatch(input.GetVariableValue(variable.Key));
+      }
     }
 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/DoubleVariable.cs	(revision 9605)
@@ -191,5 +191,14 @@
     public override void Reinitialize(IRandom random, double onePercentage, IEnumerable<IDiscretizer> descretizers) {
       Randomize(random, onePercentage, descretizers);
-      return;
+    }
+
+    public override void SetToMatch(string variableValue) {
+      var value = double.Parse(variableValue);
+      var realCutpoints = GetValuesToCutPoints(discretizer.GetCutPoints(variableName), curIntervals);
+      int pos = 0;
+      while (value >= realCutpoints[pos]) {
+        pos++;
+      }
+      attributes[pos] = true;
     }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IVariable.cs	(revision 9605)
@@ -27,4 +27,5 @@
 namespace HeuristicLab.Encodings.DecisionList {
   public interface IVariable : IItem {
+    double Length { get; }
     string VariableName { get; }
     Type VariableType { get; }
@@ -43,4 +44,6 @@
 
     void Split(IRandom Random);
+
+    void SetToMatch(string variableValue);
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/IntVariable.cs	(revision 9605)
@@ -68,4 +68,11 @@
       return attributes[possibleFeatures.IndexOf(input)];
     }
+
+    public override void SetToMatch(string variableValue) {
+      var value = int.Parse(variableValue);
+      if (!possibleFeatures.Contains(value)) throw new ArgumentException("variableValue " + variableValue + " is not a possible value of variable " + variableName);
+
+      attributes[possibleFeatures.IndexOf(value)] = true;
+    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/StringVariable.cs	(revision 9605)
@@ -64,4 +64,11 @@
       return attributes[possibleFeatures.IndexOf(input)];
     }
+
+    public override void SetToMatch(string variableValue) {
+      var valueIndex = possibleFeatures.IndexOf(variableValue);
+      if (valueIndex == -1) throw new ArgumentException("variableValue " + variableValue + " is not a possible value of variable " + variableName);
+
+      attributes[valueIndex] = true;
+    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs	(revision 9494)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Variable/Variable.cs	(revision 9605)
@@ -38,4 +38,8 @@
     }
 
+    public double Length {
+      get { return attributes.Count; }
+    }
+
     [Storable]
     protected string variableName;
@@ -72,4 +76,6 @@
     public abstract bool Match(string input);
 
+    public abstract void SetToMatch(string variableValue);
+
     public virtual string ToFullString() { throw new NotImplementedException(); }
 
