Index: branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 11684)
+++ branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 11685)
@@ -175,5 +175,5 @@
     </Compile>
     <Compile Include="Implementation\Classification\ClassificationEnsembleSolution.cs" />
-    <Compile Include="Implementation\Classification\ClassificationPerformanceMeasuresResultCollection.cs" />
+    <Compile Include="Implementation\Classification\ClassificationPerformanceMeasures.cs" />
     <Compile Include="Implementation\Classification\ClassificationProblemData.cs" />
     <Compile Include="Implementation\Classification\ClassificationProblem.cs" />
Index: branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationPerformanceMeasures.cs
===================================================================
--- branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationPerformanceMeasures.cs	(revision 11685)
+++ branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationPerformanceMeasures.cs	(revision 11685)
@@ -0,0 +1,164 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
+  public class ClassificationPerformanceMeasuresResultCollection : ResultCollection {
+    #region result names
+    protected const string ClassificationPositiveClassNameResultName = "Classification positive class";
+    protected const string TrainingTruePositiveRateResultName = "True positive rate (training)";
+    protected const string TrainingTrueNegativeRateResultName = "True negative rate (training)";
+    protected const string TrainingPositivePredictiveValueResultName = "Positive predictive value (training)";
+    protected const string TrainingNegativePredictiveValueResultName = "Negative predictive value (training)";
+    protected const string TrainingFalsePositiveRateResultName = "False positive rate (training)";
+    protected const string TrainingFalseDiscoveryRateResultName = "False discovery rate (training)";
+    protected const string TestTruePositiveRateResultName = "True positive rate (test)";
+    protected const string TestTrueNegativeRateResultName = "True negative rate (test)";
+    protected const string TestPositivePredictiveValueResultName = "Positive predictive value (test)";
+    protected const string TestNegativePredictiveValueResultName = "Negative predictive value (test)";
+    protected const string TestFalsePositiveRateResultName = "False positive rate (test)";
+    protected const string TestFalseDiscoveryRateResultName = "False discovery rate (test)";
+    #endregion
+
+    public ClassificationPerformanceMeasuresResultCollection()
+      : base() {
+      AddMeasures();
+    }
+    [StorableConstructor]
+    protected ClassificationPerformanceMeasuresResultCollection(bool deserializing)
+      : base(deserializing) {
+    }
+
+    #region result properties
+    public string ClassificationPositiveClassName {
+      get { return ((StringValue)this[ClassificationPositiveClassNameResultName].Value).Value; }
+      set { ((StringValue)this[ClassificationPositiveClassNameResultName].Value).Value = value; }
+    }
+    public double TrainingTruePositiveRate {
+      get { return ((DoubleValue)this[TrainingTruePositiveRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingTruePositiveRateResultName].Value).Value = value; }
+    }
+    public double TrainingTrueNegativeRate {
+      get { return ((DoubleValue)this[TrainingTrueNegativeRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingTrueNegativeRateResultName].Value).Value = value; }
+    }
+    public double TrainingPositivePredictiveValue {
+      get { return ((DoubleValue)this[TrainingPositivePredictiveValueResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingPositivePredictiveValueResultName].Value).Value = value; }
+    }
+    public double TrainingNegativePredictiveValue {
+      get { return ((DoubleValue)this[TrainingNegativePredictiveValueResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingNegativePredictiveValueResultName].Value).Value = value; }
+    }
+    public double TrainingFalsePositiveRate {
+      get { return ((DoubleValue)this[TrainingFalsePositiveRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingFalsePositiveRateResultName].Value).Value = value; }
+    }
+    public double TrainingFalseDiscoveryRate {
+      get { return ((DoubleValue)this[TrainingFalseDiscoveryRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TrainingFalseDiscoveryRateResultName].Value).Value = value; }
+    }
+    public double TestTruePositiveRate {
+      get { return ((DoubleValue)this[TestTruePositiveRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TestTruePositiveRateResultName].Value).Value = value; }
+    }
+    public double TestTrueNegativeRate {
+      get { return ((DoubleValue)this[TestTrueNegativeRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TestTrueNegativeRateResultName].Value).Value = value; }
+    }
+    public double TestPositivePredictiveValue {
+      get { return ((DoubleValue)this[TestPositivePredictiveValueResultName].Value).Value; }
+      set { ((DoubleValue)this[TestPositivePredictiveValueResultName].Value).Value = value; }
+    }
+    public double TestNegativePredictiveValue {
+      get { return ((DoubleValue)this[TestNegativePredictiveValueResultName].Value).Value; }
+      set { ((DoubleValue)this[TestNegativePredictiveValueResultName].Value).Value = value; }
+    }
+    public double TestFalsePositiveRate {
+      get { return ((DoubleValue)this[TestFalsePositiveRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TestFalsePositiveRateResultName].Value).Value = value; }
+    }
+    public double TestFalseDiscoveryRate {
+      get { return ((DoubleValue)this[TestFalseDiscoveryRateResultName].Value).Value; }
+      set { ((DoubleValue)this[TestFalseDiscoveryRateResultName].Value).Value = value; }
+    }
+    #endregion
+
+    protected void AddMeasures() {
+      Add(new Result(ClassificationPositiveClassNameResultName, "The positive class which is used for the performance measure calculations.", new StringValue()));
+      Add(new Result(TrainingTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the training partition\n(TP/(TP+FN)).", new PercentValue()));
+      Add(new Result(TrainingTrueNegativeRateResultName, "Specificity/True negative rate of the model on the training partition\n(TN/(FP+TN)).", new PercentValue()));
+      Add(new Result(TrainingPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the training partition\n(TP/(TP+FP)).", new PercentValue()));
+      Add(new Result(TrainingNegativePredictiveValueResultName, "Negative predictive value of the model on the training partition\n(TN/(TN+FN)).", new PercentValue()));
+      Add(new Result(TrainingFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the training partition.", new PercentValue()));
+      Add(new Result(TrainingFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the training partition.", new PercentValue()));
+      Add(new Result(TestTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the test partition\n(TP/(TP+FN)).", new PercentValue()));
+      Add(new Result(TestTrueNegativeRateResultName, "Specificity/True negative rate of the model on the test partition\n(TN/(FP+TN)).", new PercentValue()));
+      Add(new Result(TestPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the test partition\n(TP/(TP+FP)).", new PercentValue()));
+      Add(new Result(TestNegativePredictiveValueResultName, "Negative predictive value of the model on the test partition\n(TN/(TN+FN)).", new PercentValue()));
+      Add(new Result(TestFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the test partition.", new PercentValue()));
+      Add(new Result(TestFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the test partition.", new PercentValue()));
+      TrainingTruePositiveRate = double.NaN;
+      TrainingTrueNegativeRate = double.NaN;
+      TrainingPositivePredictiveValue = double.NaN;
+      TrainingNegativePredictiveValue = double.NaN;
+      TrainingFalsePositiveRate = double.NaN;
+      TrainingFalseDiscoveryRate = double.NaN;
+      TestTruePositiveRate = double.NaN;
+      TestTrueNegativeRate = double.NaN;
+      TestPositivePredictiveValue = double.NaN;
+      TestNegativePredictiveValue = double.NaN;
+      TestFalsePositiveRate = double.NaN;
+      TestFalseDiscoveryRate = double.NaN;
+    }
+
+    public void SetTrainingResults(ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator) {
+      if (!string.IsNullOrWhiteSpace(ClassificationPositiveClassName)
+              && !ClassificationPositiveClassName.Equals(trainingPerformanceCalculator.PositiveClassName))
+        throw new ArgumentException();
+      ClassificationPositiveClassName = trainingPerformanceCalculator.PositiveClassName;
+      TrainingTruePositiveRate = trainingPerformanceCalculator.TruePositiveRate;
+      TrainingTrueNegativeRate = trainingPerformanceCalculator.TrueNegativeRate;
+      TrainingPositivePredictiveValue = trainingPerformanceCalculator.PositivePredictiveValue;
+      TrainingNegativePredictiveValue = trainingPerformanceCalculator.NegativePredictiveValue;
+      TrainingFalsePositiveRate = trainingPerformanceCalculator.FalsePositiveRate;
+      TrainingFalseDiscoveryRate = trainingPerformanceCalculator.FalseDiscoveryRate;
+    }
+
+    public void SetTestResults(ClassificationPerformanceMeasuresCalculator testPerformanceCalculator) {
+      if (!string.IsNullOrWhiteSpace(ClassificationPositiveClassName)
+                && !ClassificationPositiveClassName.Equals(testPerformanceCalculator.PositiveClassName))
+        throw new ArgumentException();
+      ClassificationPositiveClassName = testPerformanceCalculator.PositiveClassName;
+      TestTruePositiveRate = testPerformanceCalculator.TruePositiveRate;
+      TestTrueNegativeRate = testPerformanceCalculator.TrueNegativeRate;
+      TestPositivePredictiveValue = testPerformanceCalculator.PositivePredictiveValue;
+      TestNegativePredictiveValue = testPerformanceCalculator.NegativePredictiveValue;
+      TestFalsePositiveRate = testPerformanceCalculator.FalsePositiveRate;
+      TestFalseDiscoveryRate = testPerformanceCalculator.FalseDiscoveryRate;
+    }
+  }
+}
Index: branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationPerformanceMeasuresResultCollection.cs
===================================================================
--- branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationPerformanceMeasuresResultCollection.cs	(revision 11684)
+++ 	(revision )
@@ -1,137 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2014 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.Data;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  [StorableClass]
-  public class ClassificationPerformanceMeasuresResultCollection : ResultCollection {
-    #region result names
-    protected const string ClassificationPositiveClassValueResultName = "Classification positive class";
-    protected const string TrainingTruePositiveRateResultName = "True positive rate (training)";
-    protected const string TrainingTrueNegativeRateResultName = "True negative rate (training)";
-    protected const string TrainingPositivePredictiveValueResultName = "Positive predictive value (training)";
-    protected const string TrainingNegativePredictiveValueResultName = "Negative predictive value (training)";
-    protected const string TrainingFalsePositiveRateResultName = "False positive rate (training)";
-    protected const string TrainingFalseDiscoveryRateResultName = "False discovery rate (training)";
-    protected const string TestTruePositiveRateResultName = "True positive rate (test)";
-    protected const string TestTrueNegativeRateResultName = "True negative rate (test)";
-    protected const string TestPositivePredictiveValueResultName = "Positive predictive value (test)";
-    protected const string TestNegativePredictiveValueResultName = "Negative predictive value (test)";
-    protected const string TestFalsePositiveRateResultName = "False positive rate (test)";
-    protected const string TestFalseDiscoveryRateResultName = "False discovery rate (test)";
-    #endregion
-
-    public ClassificationPerformanceMeasuresResultCollection()
-      : base() {
-      AddMeasures();
-    }
-    [StorableConstructor]
-    protected ClassificationPerformanceMeasuresResultCollection(bool deserializing)
-      : base(deserializing) {
-    }
-
-    #region result properties
-    public string ClassificationPositiveClassValue {
-      get { return ((StringValue)this[ClassificationPositiveClassValueResultName].Value).Value; }
-      set { ((StringValue)this[ClassificationPositiveClassValueResultName].Value).Value = value; }
-    }
-    public double TrainingTruePositiveRate {
-      get { return ((DoubleValue)this[TrainingTruePositiveRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingTruePositiveRateResultName].Value).Value = value; }
-    }
-    public double TrainingTrueNegativeRate {
-      get { return ((DoubleValue)this[TrainingTrueNegativeRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingTrueNegativeRateResultName].Value).Value = value; }
-    }
-    public double TrainingPositivePredictiveValue {
-      get { return ((DoubleValue)this[TrainingPositivePredictiveValueResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingPositivePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TrainingNegativePredictiveValue {
-      get { return ((DoubleValue)this[TrainingNegativePredictiveValueResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingNegativePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TrainingFalsePositiveRate {
-      get { return ((DoubleValue)this[TrainingFalsePositiveRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingFalsePositiveRateResultName].Value).Value = value; }
-    }
-    public double TrainingFalseDiscoveryRate {
-      get { return ((DoubleValue)this[TrainingFalseDiscoveryRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TrainingFalseDiscoveryRateResultName].Value).Value = value; }
-    }
-    public double TestTruePositiveRate {
-      get { return ((DoubleValue)this[TestTruePositiveRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TestTruePositiveRateResultName].Value).Value = value; }
-    }
-    public double TestTrueNegativeRate {
-      get { return ((DoubleValue)this[TestTrueNegativeRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TestTrueNegativeRateResultName].Value).Value = value; }
-    }
-    public double TestPositivePredictiveValue {
-      get { return ((DoubleValue)this[TestPositivePredictiveValueResultName].Value).Value; }
-      set { ((DoubleValue)this[TestPositivePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TestNegativePredictiveValue {
-      get { return ((DoubleValue)this[TestNegativePredictiveValueResultName].Value).Value; }
-      set { ((DoubleValue)this[TestNegativePredictiveValueResultName].Value).Value = value; }
-    }
-    public double TestFalsePositiveRate {
-      get { return ((DoubleValue)this[TestFalsePositiveRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TestFalsePositiveRateResultName].Value).Value = value; }
-    }
-    public double TestFalseDiscoveryRate {
-      get { return ((DoubleValue)this[TestFalseDiscoveryRateResultName].Value).Value; }
-      set { ((DoubleValue)this[TestFalseDiscoveryRateResultName].Value).Value = value; }
-    }
-    #endregion
-
-    protected void AddMeasures() {
-      Add(new Result(ClassificationPositiveClassValueResultName, "The positive class which is used for the performance measure calculations.", new StringValue()));
-      Add(new Result(TrainingTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the training partition\n(TP/(TP+FN)).", new PercentValue()));
-      Add(new Result(TrainingTrueNegativeRateResultName, "Specificity/True negative rate of the model on the training partition\n(TN/(FP+TN)).", new PercentValue()));
-      Add(new Result(TrainingPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the training partition\n(TP/(TP+FP)).", new PercentValue()));
-      Add(new Result(TrainingNegativePredictiveValueResultName, "Negative predictive value of the model on the training partition\n(TN/(TN+FN)).", new PercentValue()));
-      Add(new Result(TrainingFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the training partition.", new PercentValue()));
-      Add(new Result(TrainingFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the training partition.", new PercentValue()));
-      Add(new Result(TestTruePositiveRateResultName, "Sensitivity/True positive rate of the model on the test partition\n(TP/(TP+FN)).", new PercentValue()));
-      Add(new Result(TestTrueNegativeRateResultName, "Specificity/True negative rate of the model on the test partition\n(TN/(FP+TN)).", new PercentValue()));
-      Add(new Result(TestPositivePredictiveValueResultName, "Precision/Positive predictive value of the model on the test partition\n(TP/(TP+FP)).", new PercentValue()));
-      Add(new Result(TestNegativePredictiveValueResultName, "Negative predictive value of the model on the test partition\n(TN/(TN+FN)).", new PercentValue()));
-      Add(new Result(TestFalsePositiveRateResultName, "The false positive rate is the complement of the true negative rate of the model on the test partition.", new PercentValue()));
-      Add(new Result(TestFalseDiscoveryRateResultName, "The false discovery rate is the complement of the positive predictive value of the model on the test partition.", new PercentValue()));
-      TrainingTruePositiveRate = double.NaN;
-      TrainingTrueNegativeRate = double.NaN;
-      TrainingPositivePredictiveValue = double.NaN;
-      TrainingNegativePredictiveValue = double.NaN;
-      TrainingFalsePositiveRate = double.NaN;
-      TrainingFalseDiscoveryRate = double.NaN;
-      TestTruePositiveRate = double.NaN;
-      TestTrueNegativeRate = double.NaN;
-      TestPositivePredictiveValue = double.NaN;
-      TestNegativePredictiveValue = double.NaN;
-      TestFalsePositiveRate = double.NaN;
-      TestFalseDiscoveryRate = double.NaN;
-    }
-  }
-}
Index: branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs
===================================================================
--- branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 11684)
+++ branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 11685)
@@ -108,7 +108,6 @@
       var positiveClassName = ProblemData.PositiveClassName;
       double positiveClassValue = ProblemData.GetClassValue(positiveClassName);
-      ClassificationPerformanceMeasures.ClassificationPositiveClassValue = positiveClassName;
-      ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassValue);
-      ClassificationPerformanceMeasuresCalculator testPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassValue);
+      ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
+      ClassificationPerformanceMeasuresCalculator testPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
 
       OnlineCalculatorError errorState;
@@ -130,21 +129,9 @@
 
       trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
-      if (errorState == OnlineCalculatorError.None) {
-        ClassificationPerformanceMeasures.TrainingTruePositiveRate = trainingPerformanceCalculator.TruePositiveRate;
-        ClassificationPerformanceMeasures.TrainingTrueNegativeRate = trainingPerformanceCalculator.TrueNegativeRate;
-        ClassificationPerformanceMeasures.TrainingPositivePredictiveValue = trainingPerformanceCalculator.PositivePredictiveValue;
-        ClassificationPerformanceMeasures.TrainingNegativePredictiveValue = trainingPerformanceCalculator.NegativePredictiveValue;
-        ClassificationPerformanceMeasures.TrainingFalsePositiveRate = trainingPerformanceCalculator.FalsePositiveRate;
-        ClassificationPerformanceMeasures.TrainingFalseDiscoveryRate = trainingPerformanceCalculator.FalseDiscoveryRate; 
-      }
+      if (errorState == OnlineCalculatorError.None)
+        ClassificationPerformanceMeasures.SetTrainingResults(trainingPerformanceCalculator);
       testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
-      if (errorState == OnlineCalculatorError.None) {
-        ClassificationPerformanceMeasures.TestTruePositiveRate = testPerformanceCalculator.TruePositiveRate;
-        ClassificationPerformanceMeasures.TestTrueNegativeRate = testPerformanceCalculator.TrueNegativeRate;
-        ClassificationPerformanceMeasures.TestPositivePredictiveValue = testPerformanceCalculator.PositivePredictiveValue;
-        ClassificationPerformanceMeasures.TestNegativePredictiveValue = testPerformanceCalculator.NegativePredictiveValue;
-        ClassificationPerformanceMeasures.TestFalsePositiveRate = testPerformanceCalculator.FalsePositiveRate;
-        ClassificationPerformanceMeasures.TestFalseDiscoveryRate = testPerformanceCalculator.FalseDiscoveryRate;
-      }
+      if (errorState == OnlineCalculatorError.None)
+        ClassificationPerformanceMeasures.SetTestResults(testPerformanceCalculator);
     }
 
Index: branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs
===================================================================
--- branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs	(revision 11684)
+++ branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs	(revision 11685)
@@ -29,5 +29,6 @@
   public class ClassificationPerformanceMeasuresCalculator {
 
-    public ClassificationPerformanceMeasuresCalculator(double positiveClassValue) {
+    public ClassificationPerformanceMeasuresCalculator(string positiveClassName, double positiveClassValue) {
+      this.positiveClassName = positiveClassName;
       this.positiveClassValue = positiveClassValue;
       Reset();        
@@ -35,7 +36,18 @@
 
     #region Properties
+    private string positiveClassName;
     private double positiveClassValue;
     private int truePositiveCount, falsePositiveCount, trueNegativeCount, falseNegativeCount;
 
+    public string PositiveClassName {
+      get {
+        return positiveClassName;
+      }
+    }
+    public double PositiveClassValue {
+      get {
+        return positiveClassValue;
+      }
+    }
     public double TruePositiveRate {
       get {
