Changeset 11761 for branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs

Timestamp:

01/15/15 11:16:05 (10 years ago)

Author:

mkommend

Message:

#2278: Minor code cleanup in classification extensions.

File:

• branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs (modified) (5 diffs)

branches/Classification-Extensions/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/ClassificationPerformanceMeasuresCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using HeuristicLab.Common;
 
@@ -32 +30 @@
       this.positiveClassName = positiveClassName;
       this.positiveClassValue = positiveClassValue;
-      Reset();        
+      Reset();
     }
 
     #region Properties
-    private string positiveClassName;
-    private double positiveClassValue;
     private int truePositiveCount, falsePositiveCount, trueNegativeCount, falseNegativeCount;
 
+    private readonly string positiveClassName;
     public string PositiveClassName {
-      get {
-        return positiveClassName;
-      }
+      get { return positiveClassName; }
     }
+
+    private readonly double positiveClassValue;
     public double PositiveClassValue {
-      get {
-        return positiveClassValue;
-      }
+      get { return positiveClassValue; }
     }
     public double TruePositiveRate {
@@ -92 +87 @@
     }
     #endregion
-                                
+
     public void Reset() {
       truePositiveCount = 0;
@@ -103 +98 @@
     public void Add(double originalClassValue, double estimatedClassValue) {
       // ignore cases where original is NaN completely 
-      if (!double.IsNaN(originalClassValue)) {
-        if (originalClassValue.IsAlmost(positiveClassValue) 
-              || estimatedClassValue.IsAlmost(positiveClassValue)) { //positive class/positive class estimation
-          if (estimatedClassValue.IsAlmost(originalClassValue)) {
-            truePositiveCount++;
-          } else {
-            if (estimatedClassValue.IsAlmost(positiveClassValue)) //misclassification of the negative class
-              falsePositiveCount++;
-            else //misclassification of the positive class
-              falseNegativeCount++;
-          }
-        } else { //negative class/negative class estimation
-          //In a multiclass classification all misclassifications of the negative class
-          //will be treated as true negatives except on positive class estimations
-          trueNegativeCount++;
+      if (double.IsNaN(originalClassValue)) return;
+
+      if (originalClassValue.IsAlmost(positiveClassValue)
+            || estimatedClassValue.IsAlmost(positiveClassValue)) { //positive class/positive class estimation
+        if (estimatedClassValue.IsAlmost(originalClassValue)) {
+          truePositiveCount++;
+        } else {
+          if (estimatedClassValue.IsAlmost(positiveClassValue)) //misclassification of the negative class
+            falsePositiveCount++;
+          else //misclassification of the positive class
+            falseNegativeCount++;
         }
-        errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1
+      } else { //negative class/negative class estimation
+        //In a multiclass classification all misclassifications of the negative class
+        //will be treated as true negatives except on positive class estimations
+        trueNegativeCount++;
       }
+
+      errorState = OnlineCalculatorError.None; // number of (non-NaN) samples >= 1
     }
 
-    public void Calculate(IEnumerable<double> originalClassValues, IEnumerable<double> estimatedClassValues,
-                                                                          out OnlineCalculatorError errorState) {
+    public void Calculate(IEnumerable<double> originalClassValues, IEnumerable<double> estimatedClassValues) {
       IEnumerator<double> originalEnumerator = originalClassValues.GetEnumerator();
       IEnumerator<double> estimatedEnumerator = estimatedClassValues.GetEnumerator();
@@ -137 +132 @@
 
       // check if both enumerators are at the end to make sure both enumerations have the same length
-      if (ErrorState == OnlineCalculatorError.None &&
-          (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) {
+      if (ErrorState == OnlineCalculatorError.None && (estimatedEnumerator.MoveNext() || originalEnumerator.MoveNext())) {
         throw new ArgumentException("Number of elements in originalValues and estimatedValues enumerations doesn't match.");
-      } else {
-        errorState = ErrorState;
       }
+      errorState = ErrorState;
     }
   }