Changeset 1605

Timestamp:

04/18/09 13:26:48 (16 years ago)

Author:

cbahner

Message:

#519 implemented performance improvements for avg aggregators

Location:

trunk/sources/HeuristicLab.Visualization/3.2

Files:

• AvgAggregator.cs (modified) (2 diffs)
• AvgLineAggregator.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.Visualization/3.2/AvgAggregator.cs

@@ -26 +26 @@
 
     private void dataRow_ValueChanged(IDataRow row, double value, int index, Action action) {
-      refreshValue(value);
+      switch (action) {
+        case Action.Added:
+          refreshValue(value, action);
+          break;
+        case Action.Modified:
+          refreshValue();
+          break;
+        case Action.Deleted:
+          refreshValue(value, action);
+          break;
+        default:
+          throw new ArgumentOutOfRangeException("action");
+      }
+
+
     }
 
     private void dataRow_ValuesChanged(IDataRow row, double[] values, int index, Action action) {
       for (int i = 0; i < values.Length; i++) {
-        refreshValue(values[i]);
+        refreshValue();
       }
     }
 
     private void dataRow_DataRowChanged(IDataRow row) {
-      refreshValue(double.MinValue);
+      refreshValue();
     }
 
-    private void refreshValue(double newVal) {
-      //alle durchlaufen und neues min berechnen; verbesserung: merken in welcher row lowest wert steckt
+    private int count;
+    
+    public AvgAggregator() {
+      curAvgValue = 0;
+      count = 0;
+    }
 
+    private void refreshValue() {
       curAvgValue = double.MinValue;
       double tmpSum = 0;
-      int count = 0;
+      count = 0;
       foreach (IDataRow rows in dataRowWatches) {
         for (int i = 0; i < rows.Count; i++) {
@@ -51 +70 @@
         }
       }
-      curAvgValue = tmpSum/count;
-      // evtl nur feuern wenn sich geändert hat (jedes mal?)
+      if (count == 0) curAvgValue = 0;
+      else curAvgValue = tmpSum / count;
+      OnValueChanged(curAvgValue, 0, Action.Modified);
+    }
+    private void refreshValue(double newVal, Action action) {
+      double temp = curAvgValue * count;
+
+      switch (action) {
+        case Action.Added:
+          temp += newVal;
+          count++;
+          break;
+        case Action.Modified:
+          throw new InvalidOperationException();
+        case Action.Deleted:
+          temp -= newVal;
+          count--;
+          break;
+        default:
+          throw new ArgumentOutOfRangeException("action");
+      }
+
+      curAvgValue = temp / count;
       OnValueChanged(curAvgValue, 0, Action.Modified);
     }

trunk/sources/HeuristicLab.Visualization/3.2/AvgLineAggregator.cs

@@ -28 +28 @@
 
     List<IDataRow> dataRowWatches = new List<IDataRow>();
-    
+
     void dataRow_ValueChanged(IDataRow row, double value, int index, Action action) {
-      refreshValue(value);
+      switch (action) {
+        case Action.Added:
+          refreshValue(row, value, Action.Added);
+          break;
+        case Action.Modified:
+          refreshValue();
+          break;
+        case Action.Deleted:
+          refreshValue(row, value, Action.Deleted);
+          break;
+        default:
+          throw new ArgumentOutOfRangeException("action");
+      }
+
     }
 
     void dataRow_ValuesChanged(IDataRow row, double[] values, int index, Action action) {
       for (int i = 0; i < values.Length; i++) {
-        refreshValue(values[i]);
+        refreshValue();
       }
     }
 
     void dataRow_DataRowChanged(IDataRow row) {
-      refreshValue(double.MinValue);
-    }
-
-    private void refreshValue(double newVal) {
-      //alle durchlaufen und neues min berechnen; verbesserung: merken in welcher row lowest wert steckt
-
-      //curAvgValue = double.MinValue;
+      refreshValue();
+    }
+
+    private void refreshValue() {
       double tmpSum = 0;
       int count = dataRowWatches.Count;
@@ -65 +75 @@
           }
 
-          this.dataRow.Add(tmpSum/count);
+          this.dataRow.Add(tmpSum / count);
           OnValueChanged(tmpSum / count, dataRow.Count - 1, Action.Added);
         }
       }
+    }
+
+    private void refreshValue(IDataRow row, double newVal, Action action) {
+
+      int index = row.Count - 1;
+
+
+      
+      
+      double curAvg = 0;
+//      if (dataRow.Count > 0) {
+//        curAvg = dataRow[0];   //?
+//      } else {
+//        curAvg = 0;
+//      }
+
+
+      foreach (IDataRow watch in dataRowWatches) {
+        if (watch.Count >= index +1) {
+          curAvg += watch[index];
+          
+        }
+        //curAvg += watch[watch.Count - 1];
+      }
+
+      if (dataRowWatches.Count > 0)
+        curAvg /= dataRowWatches.Count;
+
+
+      if (dataRow.Count <= index) {
+        dataRow.Add(curAvg);
+        OnValueChanged(curAvg, dataRow.Count - 1, Action.Added);     
+      }
+      else {
+        dataRow[index] = curAvg;
+        OnValueChanged(curAvg, dataRow.Count - 1, Action.Modified);  
+      }
+
+
+
+//      curAvg *= dataRow.Count * dataRowWatches.Count;
+//      switch (action) {
+//        case Action.Added:
+//          curAvg += newVal;
+//          break;
+//        case Action.Modified:
+//          throw new InvalidOperationException();
+//        case Action.Deleted:
+//          curAvg -= newVal;
+//          break;
+//        default:
+//          throw new ArgumentOutOfRangeException("action");
+//      }
+//
+//      dataRow.Add((curAvg / (dataRow.Count + 1)) / dataRowWatches.Count);
+//      OnValueChanged((curAvg / (dataRow.Count + 1)) / dataRowWatches.Count, dataRow.Count - 1, Action.Added); // nicht immer adden!
+
+      //      double tmpSum = 0;
+      //      int count = dataRowWatches.Count;
+      //
+      //      IDataRow firstRow = dataRowWatches[0];
+      //      int count1 = firstRow.Count;
+      //      System.Console.WriteLine("count: " + count1);
+      //
+      //      dataRow.Clear();
+      //
+      //      if (dataRowWatches.Count >= 2) {
+      //        for (int i = 0; i < count1; i++) {
+      //          tmpSum = 0;
+      //          for (int j = 0; j < count; j++) {
+      //            if (dataRowWatches[j].Count > i) {
+      //              tmpSum += dataRowWatches[j][i];
+      //            }
+      //          }
+      //
+      //          this.dataRow.Add(tmpSum/count);
+      //          OnValueChanged(tmpSum / count, dataRow.Count - 1, Action.Added);
+      //        }
+      //      }
 
       // evtl nur feuern wenn sich geändert hat (jedes mal?)