Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/DecisionListSolution.cs	(revision 9475)
@@ -137,5 +137,5 @@
       double theoryLength;
       var estimatedTraining = Model.Evaluate(originalTrainingCondition, out aliveRules, out theoryLength);
-      TrainingNumberOfAliveRules = aliveRules.Count;
+      TrainingNumberOfAliveRules = aliveRules.Count + (Model.DefaultAction != null ? 1 : 0);
       TrainingAliveRules = aliveRules;
       TrainingTheoryLength = theoryLength;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.DecisionList/3.3/Evaluator/MDLEvaluator.cs	(revision 9475)
@@ -145,5 +145,5 @@
 
     // default rule cannot be deleted, but it has to be considered in the rule set size
-    private void DoRuleDeletion(DecisionList dl, ItemSet<Rule> aliveRules, int minRules) {
+    private void DoRuleDeletion(DecisionList dl, IEnumerable<Rule> aliveRules, int minRules) {
       int ruleSetSize = dl.RuleSetSize;
       if (ruleSetSize <= minRules) { return; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9475)
@@ -52,5 +52,5 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadpercentage) {
       return Manipulate(random, child, PossibleActionsParameter.ActualValue);
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9475)
@@ -45,9 +45,9 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
-      return Manipulate(random, input, child, random.Next(child.Condition.VirtualLength));
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage) {
+      return Manipulate(random, input, child, random.Next(child.Condition.VirtualLength), spreadPercentage);
     }
 
-    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, int index) {
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, int index, double spreadPercentage) {
       VariableVectorCondition condition = child.Condition;
       if (index >= condition.VirtualLength) {
@@ -61,5 +61,5 @@
         keyEnumerator.MoveNext();
       }
-      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count);
+      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count, spreadPercentage);
       return child;
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9475)
@@ -55,17 +55,17 @@
     }
 
-    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
-      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage) {
+      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue, spreadPercentage);
     }
 
-    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions) {
-      child = ManipulateCondition(random, input, child, probability);
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions, double spreadPercentage) {
+      child = ManipulateCondition(random, input, child, probability, spreadPercentage);
       return ManipulateAction(random, child, probability, possibleActions);
     }
 
-    public static VariableVector ManipulateCondition(IRandom random, VariableVectorInput input, VariableVector child, double probability) {
+    public static VariableVector ManipulateCondition(IRandom random, VariableVectorInput input, VariableVector child, double probability, double spreadPercentage) {
       for (int index = 0; index < child.Condition.VirtualLength; index++) {
         if (random.NextDouble() < probability) {
-          child = UniformOnePositionInConditionManipulator.Manipulate(random, input, child, index);
+          child = UniformOnePositionInConditionManipulator.Manipulate(random, input, child, index, spreadPercentage);
         }
       }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9475)
@@ -124,5 +124,5 @@
       double delta = Max - Min;
       CurrentCenter = random.NextDouble() * delta + Min;
-      CurrentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+      CurrentSpread = random.NextDouble() * (delta * spreadPercentage);
     }
 
@@ -162,7 +162,11 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                   double spreadPercentage) {
+      Manipulate(random, pos, spreadPercentage);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
-      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
-      Manipulate(random, pos, 10);
+      throw new NotImplementedException("DoubleVariable.Manipulate(IRandom, string, int) cannot be used. Use DoubleVariable.Manipulate(IRandom, string, int, double) or DoubleVariable.Manipulate(IRandom, int, double) instead.");
     }
 
@@ -170,5 +174,5 @@
       if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
       double delta = max - min;
-      double maxChange = delta * (percentage / 100);
+      double maxChange = delta * percentage;
       double actualChange = (random.NextDouble() * maxChange * 2) - maxChange;
       if (pos == 0) {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9475)
@@ -46,4 +46,6 @@
     void Manipulate(IRandom random, string stringValue, int pos);
 
+    void Manipulate(IRandom random, string stringValue, int pos, double spreadPercentage);
+
     void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9475)
@@ -166,4 +166,9 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                   double spreadPercentage) {
+      Manipulate(random, stringValue, pos);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9475)
@@ -87,5 +87,5 @@
       featureMapping = new Dictionary<int, string>();
       var distinctValuesEnumerator = variableValues.Distinct().GetEnumerator();
-      possibleFeatures = Enumerable.Range(0, variableValues.Count());
+      possibleFeatures = Enumerable.Range(0, variableValues.Count()).ToList();
       var possibleFeaturesEnumerator = possibleFeatures.GetEnumerator();
       while (possibleFeaturesEnumerator.MoveNext() && distinctValuesEnumerator.MoveNext()) {
@@ -111,5 +111,5 @@
         throw new ArgumentException("featureMapping values have to be distinct.");
       }
-      this.possibleFeatures = featureMapping.Keys;
+      this.possibleFeatures = featureMapping.Keys.ToList();
       this.featureMapping = featureMapping;
       Wildcard = false;
@@ -212,4 +212,9 @@
     }
 
+    public override void Manipulate(IRandom random, string stringValue, int pos,
+                                    double spreadPercentage) {
+      Manipulate(random, stringValue, pos);
+    }
+
     public override void Manipulate(IRandom random, string stringValue, int pos) {
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9475)
@@ -72,4 +72,6 @@
     public abstract void Manipulate(IRandom random, string stringValue, int pos);
 
+    public abstract void Manipulate(IRandom random, string stringValue, int pos, double spreadPercentage);
+
     public abstract void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs	(revision 9475)
@@ -42,4 +42,7 @@
       get { return (ILookupParameter<VariableVectorInput>)Parameters["Input"]; }
     }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
+    }
     #endregion
 
@@ -54,12 +57,13 @@
       Parameters.Add(new LookupParameter<VariableVector>("Child"));
       Parameters.Add(new LookupParameter<VariableVectorInput>("Input"));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData", ""));
     }
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue, ProblemDataParameter.ActualValue.SpreadPercentageParameter.Value.Value);
       return base.Apply();
     }
 
-    protected abstract VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child);
+    protected abstract VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double spreadPercentage);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/MDL/MDLCalculator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/MDL/MDLCalculator.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/GAssist/MDL/MDLCalculator.cs	(revision 9475)
@@ -82,4 +82,8 @@
         double error = bestSolution.TrainingExceptionsLength;
         double tl = (bestSolution.TrainingTheoryLength * bestSolution.Classes) / bestSolution.TrainingNumberOfAliveRules;
+        if (tl.IsAlmost(0.0)) {
+          //as done in the original implementation
+          tl = 0.00000001;
+        }
         theoryWeight = (initialTheoryLengthRatio / (1.0 - initialTheoryLengthRatio)) * (error / tl);
         iterationsSinceBest = 0;
@@ -87,10 +91,10 @@
 
       if (activated && !fixedWeight &&
-        GetLastIterationsAccuracyAverage(weightAdaptionIterations) == 1.0) {
+        GetLastIterationsAccuracyAverage(weightAdaptionIterations).IsAlmost(1.0)) {
         fixedWeight = true;
       }
 
       if (activated && !fixedWeight) {
-        if (bestSolution.TrainingAccuracy != 1.0) {
+        if (bestSolution.TrainingAccuracy.IsAlmost(1.0)) {
           if (iterationsSinceBest == weightAdaptionIterations) {
             theoryWeight *= weightRelaxFactor;
@@ -100,7 +104,5 @@
       }
 
-      //if (currentIteration != 0) {
       UpdateStatistic(bestSolution.TrainingAccuracy);
-      //}
     }
 
Index: /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Optimization.Operators.LCS/3.3/Selection/NichingTournamentSelector.cs	(revision 9475)
@@ -83,5 +83,5 @@
       //check if list with indexes is as long as the original scope list
       //otherwise invalid quality values were filtered
-      if (qualities.Count != scopes.Count && individuals.Count != scopes.Count) {
+      if (qualities.Count != scopes.Count || individuals.Count != scopes.Count) {
         throw new ArgumentException("The scopes contain invalid quality values (either infinity or double.NaN) on which the selector cannot operate.");
       }
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs	(revision 9475)
@@ -132,4 +132,5 @@
       manipulator.FetchedInputParameter.ActualName = ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
       manipulator.PossibleActionsParameter.ActualName = PossibleActionsConcreteClassParameter.Name;
+      manipulator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
       return new List<IManipulator>() { manipulator };
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs	(revision 9474)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs	(revision 9475)
@@ -136,4 +136,5 @@
     protected override void ActionConditionVariablesChanged() {
       SampleVariableVectorParameter.Value = GenerateSampleVariableVector(Dataset, AllowedConditionVariables, AllowedActionVariables);
+      OnChanged();
     }
   }
