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 9392)
@@ -27,4 +27,5 @@
 using HeuristicLab.Data;
 using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators.LCS;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -38,4 +39,5 @@
     private const string TestAccuracyResultName = "Accuracy (test)";
     private const string TrainingNumberOfAliveRulesName = "Number of alive rules (training)";
+    private const string TrainingAliveRulesName = "Alive Rules (training)";
     //private const string TestNumberOfAliveRules = "Number of alive rules (test)";
     private const string TrainingTheoryLengthName = "Theory Length (training)";
@@ -54,4 +56,8 @@
       private set { ((IntValue)this[TrainingNumberOfAliveRulesName].Value).Value = value; }
     }
+    public ItemSet<Rule> TrainingAliveRules {
+      get { return (ItemSet<Rule>)this[TrainingAliveRulesName].Value; }
+      private set { this[TrainingAliveRulesName].Value = value; }
+    }
     public double TrainingTheoryLength {
       get { return ((DoubleValue)this[TrainingTheoryLengthName].Value).Value; }
@@ -61,4 +67,8 @@
       get { return ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value; }
       private set { ((DoubleValue)this[TrainingExceptionsLengthName].Value).Value = value; }
+    }
+
+    public int Classes {
+      get { return ProblemData.Classes; }
     }
 
@@ -79,6 +89,6 @@
     }
 
-    public IDecisionListClassificationProblemData ProblemData {
-      get { return (IDecisionListClassificationProblemData)this[ProblemDataResultName].Value; }
+    public IGAssistNichesProblemData ProblemData {
+      get { return (IGAssistNichesProblemData)this[ProblemDataResultName].Value; }
       set {
         if (this[ProblemDataResultName].Value != value) {
@@ -100,5 +110,5 @@
       description = original.Description;
     }
-    public DecisionListSolution(DecisionList model, IDecisionListClassificationProblemData problemData)
+    public DecisionListSolution(DecisionList model, IGAssistNichesProblemData problemData)
       : base() {
       name = ItemName;
@@ -109,4 +119,5 @@
       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(TrainingAliveRulesName, "", new ItemSet<Rule>()));
       Add(new Result(TrainingTheoryLengthName, "", new DoubleValue()));
       Add(new Result(TrainingExceptionsLengthName, "", new DoubleValue()));
@@ -123,8 +134,9 @@
       var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
       var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
-      int numberOfAliveRules;
+      ItemSet<Rule> aliveRules;
       double theoryLength;
-      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out numberOfAliveRules, out theoryLength);
-      TrainingNumberOfAliveRules = numberOfAliveRules;
+      var estimatedTraining = Model.Evaluate(originalTrainingCondition, out aliveRules, out theoryLength);
+      TrainingNumberOfAliveRules = aliveRules.Count;
+      TrainingAliveRules = aliveRules;
       TrainingTheoryLength = theoryLength;
       var estimatedTest = Model.Evaluate(originalTestCondition);
@@ -139,5 +151,5 @@
     }
 
-    private double CalculateAccuracy(IEnumerable<IAction> original, IEnumerable<IAction> estimated) {
+    public static double CalculateAccuracy(IEnumerable<IGAssistNiche> original, IEnumerable<IGAssistNiche> estimated) {
       double correctClassified = 0;
 
@@ -147,5 +159,6 @@
 
       while (originalEnumerator.MoveNext() && estimatedActionEnumerator.MoveNext()) {
-        if (originalEnumerator.Current.Match(estimatedActionEnumerator.Current)) {
+        if (originalEnumerator.Current != null && estimatedActionEnumerator.Current != null
+          && originalEnumerator.Current.SameNiche(estimatedActionEnumerator.Current)) {
           correctClassified++;
         }
