Index: branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/NormalizedGiniCalculator.cs
===================================================================
--- branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/NormalizedGiniCalculator.cs	(revision 6988)
+++ branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/NormalizedGiniCalculator.cs	(revision 7215)
@@ -37,5 +37,5 @@
       if (errorState != OnlineCalculatorError.None) return double.NaN;
 
-      return oe / (Gini(originalValuesArr, estimatedValuesArr, out errorState));
+      return oe / (Gini(originalValuesArr, originalValuesArr, out errorState));
     }
 
Index: branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineDirectionalSymmetryCalculator.cs
===================================================================
--- branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineDirectionalSymmetryCalculator.cs	(revision 6988)
+++ 	(revision )
@@ -1,113 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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 System.Collections.Generic;
-using HeuristicLab.Common;
-
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  public class OnlineDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator {
-    private int n;
-    private int nCorrect;
-
-    public double DirectionalSymmetry {
-      get {
-        if (n < 1) return 0.0;
-        return (double)nCorrect / n;
-      }
-    }
-
-    public OnlineDirectionalSymmetryCalculator() {
-      Reset();
-    }
-
-    public double Value {
-      get { return DirectionalSymmetry; }
-    }
-
-    private OnlineCalculatorError errorState;
-    public OnlineCalculatorError ErrorState {
-      get { return errorState; }
-    }
-
-    public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) {
-      if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
-        errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-      } else {
-        var actualEnumerator = actualContinuation.GetEnumerator();
-        var predictedEnumerator = predictedContinuation.GetEnumerator();
-        double prevActual = startValue;
-        double prevPredicted = startValue;
-        while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & errorState != OnlineCalculatorError.InvalidValueAdded) {
-          double actual = actualEnumerator.Current;
-          double predicted = predictedEnumerator.Current;
-          if (double.IsNaN(actual) || double.IsNaN(predicted)) {
-            errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-          } else {
-            // count a prediction correct if the trend (positive/negative/no change) is predicted correctly
-            if ((actual - prevActual) * (predicted - prevPredicted) > 0.0 ||
-                (actual - prevActual).IsAlmost(predicted - prevPredicted)
-              ) {
-              nCorrect++;
-            }
-            n++;
-          }
-        }
-        // check if both enumerators are at the end to make sure both enumerations have the same length
-        if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) {
-          errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-        } else {
-          errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1
-        }
-      }
-    }
-
-    public void Reset() {
-      n = 0;
-      nCorrect = 0;
-      errorState = OnlineCalculatorError.InsufficientElementsAdded;
-    }
-
-
-    public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) {
-      IEnumerator<double> startValueEnumerator = startValues.GetEnumerator();
-      IEnumerator<IEnumerable<double>> actualContinuationsEnumerator = actualContinuations.GetEnumerator();
-      IEnumerator<IEnumerable<double>> predictedContinuationsEnumerator = predictedContinuations.GetEnumerator();
-      OnlineDirectionalSymmetryCalculator dsCalculator = new OnlineDirectionalSymmetryCalculator();
-
-      // always move forward all enumerators (do not use short-circuit evaluation!)
-      while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) {
-        dsCalculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current);
-        if (dsCalculator.ErrorState != OnlineCalculatorError.None) break;
-      }
-
-      // check if all enumerators are at the end to make sure both enumerations have the same length
-      if (dsCalculator.ErrorState == OnlineCalculatorError.None &&
-          (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) {
-        throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match.");
-      } else {
-        errorState = dsCalculator.ErrorState;
-        return dsCalculator.DirectionalSymmetry;
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs
===================================================================
--- branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs	(revision 6988)
+++ 	(revision )
@@ -1,112 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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 System.Collections.Generic;
-using HeuristicLab.Common;
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  public class OnlineTheilsUStatisticCalculator : IOnlineTimeSeriesCalculator {
-    private OnlineMeanAndVarianceCalculator squaredErrorMeanCalculator;
-    private OnlineMeanAndVarianceCalculator unbiasedEstimatorMeanCalculator;
-
-    public double TheilsUStatistic {
-      get {
-        return Math.Sqrt(squaredErrorMeanCalculator.Mean) / Math.Sqrt(unbiasedEstimatorMeanCalculator.Mean);
-      }
-    }
-
-    private OnlineCalculatorError errorState;
-    public OnlineCalculatorError ErrorState {
-      get { return errorState | squaredErrorMeanCalculator.MeanErrorState | unbiasedEstimatorMeanCalculator.MeanErrorState; }
-    }
-
-    public OnlineTheilsUStatisticCalculator() {
-      squaredErrorMeanCalculator = new OnlineMeanAndVarianceCalculator();
-      unbiasedEstimatorMeanCalculator = new OnlineMeanAndVarianceCalculator();
-      Reset();
-    }
-
-    #region IOnlineEvaluator Members
-    public double Value {
-      get { return TheilsUStatistic; }
-    }
-
-    public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) {
-      if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
-        errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-      } else {
-        var actualEnumerator = actualContinuation.GetEnumerator();
-        var predictedEnumerator = predictedContinuation.GetEnumerator();
-        while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & ErrorState != OnlineCalculatorError.InvalidValueAdded) {
-          double actual = actualEnumerator.Current;
-          double predicted = predictedEnumerator.Current;
-          if (double.IsNaN(actual) || double.IsNaN(predicted)) {
-            errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-          } else {
-            // error of predicted change
-            double errorPredictedChange = (predicted - startValue) - (actual - startValue);
-            squaredErrorMeanCalculator.Add(errorPredictedChange * errorPredictedChange);
-
-            double errorNoChange = (actual - startValue);
-            unbiasedEstimatorMeanCalculator.Add(errorNoChange * errorNoChange);
-          }
-        }
-        // check if both enumerators are at the end to make sure both enumerations have the same length
-        if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) {
-          errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-        } else {
-          errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1
-        }
-      }
-    }
-
-    public void Reset() {
-      squaredErrorMeanCalculator.Reset();
-      unbiasedEstimatorMeanCalculator.Reset();
-      errorState = OnlineCalculatorError.InsufficientElementsAdded;
-    }
-
-    #endregion
-
-    public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) {
-      IEnumerator<double> startValueEnumerator = startValues.GetEnumerator();
-      IEnumerator<IEnumerable<double>> actualContinuationsEnumerator = actualContinuations.GetEnumerator();
-      IEnumerator<IEnumerable<double>> predictedContinuationsEnumerator = predictedContinuations.GetEnumerator();
-      OnlineTheilsUStatisticCalculator calculator = new OnlineTheilsUStatisticCalculator();
-
-      // always move forward all enumerators (do not use short-circuit evaluation!)
-      while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) {
-        calculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current);
-        if (calculator.ErrorState != OnlineCalculatorError.None) break;
-      }
-
-      // check if all enumerators are at the end to make sure both enumerations have the same length
-      if (calculator.ErrorState == OnlineCalculatorError.None &&
-          (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) {
-        throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match.");
-      } else {
-        errorState = calculator.ErrorState;
-        return calculator.TheilsUStatistic;
-      }
-    }
-  }
-}
Index: branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedDirectionalSymmetryCalculator.cs
===================================================================
--- branches/HeuristicLab.Hive.Azure/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineWeightedDirectionalSymmetryCalculator.cs	(revision 6988)
+++ 	(revision )
@@ -1,115 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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 System.Collections.Generic;
-using HeuristicLab.Common;
-
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  public class OnlineWeightedDirectionalSymmetryCalculator : IOnlineTimeSeriesCalculator {
-    private int n;
-    private double correctSum;
-    private double incorrectSum;
-
-    public double WeightedDirectionalSymmetry {
-      get {
-        if (n <= 1) return 0.0;
-        return incorrectSum / correctSum;
-      }
-    }
-
-    public OnlineWeightedDirectionalSymmetryCalculator() {
-      Reset();
-    }
-
-    public double Value {
-      get { return WeightedDirectionalSymmetry; }
-    }
-
-    private OnlineCalculatorError errorState;
-    public OnlineCalculatorError ErrorState {
-      get { return errorState; }
-    }
-
-    public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) {
-      if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
-        errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-      } else {
-        var actualEnumerator = actualContinuation.GetEnumerator();
-        var predictedEnumerator = predictedContinuation.GetEnumerator();
-        while (actualEnumerator.MoveNext() & predictedEnumerator.MoveNext() & errorState != OnlineCalculatorError.InvalidValueAdded) {
-          double actual = actualEnumerator.Current;
-          double predicted = predictedEnumerator.Current;
-          if (double.IsNaN(actual) || double.IsNaN(predicted)) {
-            errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-          } else {
-            double err = Math.Abs(actual - predicted);
-            // count as correct only if the trend (positive/negative/no change) is predicted correctly
-            if ((actual - startValue) * (predicted - startValue) > 0.0 ||
-              (actual - startValue).IsAlmost(predicted - startValue)) {
-              correctSum += err;
-            } else {
-              incorrectSum += err;
-            }
-            n++;
-          }
-        }
-        // check if both enumerators are at the end to make sure both enumerations have the same length
-        if (actualEnumerator.MoveNext() || predictedEnumerator.MoveNext()) {
-          errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
-        } else {
-          errorState = errorState & (~OnlineCalculatorError.InsufficientElementsAdded); // n >= 1
-        }
-      }
-    }
-
-    public void Reset() {
-      n = 0;
-      correctSum = 0;
-      incorrectSum = 0;
-      errorState = OnlineCalculatorError.InsufficientElementsAdded;
-    }
-
-
-    public static double Calculate(IEnumerable<double> startValues, IEnumerable<IEnumerable<double>> actualContinuations, IEnumerable<IEnumerable<double>> predictedContinuations, out OnlineCalculatorError errorState) {
-      IEnumerator<double> startValueEnumerator = startValues.GetEnumerator();
-      IEnumerator<IEnumerable<double>> actualContinuationsEnumerator = actualContinuations.GetEnumerator();
-      IEnumerator<IEnumerable<double>> predictedContinuationsEnumerator = predictedContinuations.GetEnumerator();
-      OnlineWeightedDirectionalSymmetryCalculator calculator = new OnlineWeightedDirectionalSymmetryCalculator();
-
-      // always move forward all enumerators (do not use short-circuit evaluation!)
-      while (startValueEnumerator.MoveNext() & actualContinuationsEnumerator.MoveNext() & predictedContinuationsEnumerator.MoveNext()) {
-        calculator.Add(startValueEnumerator.Current, actualContinuationsEnumerator.Current, predictedContinuationsEnumerator.Current);
-        if (calculator.ErrorState != OnlineCalculatorError.None) break;
-      }
-
-      // check if all enumerators are at the end to make sure both enumerations have the same length
-      if (calculator.ErrorState == OnlineCalculatorError.None &&
-          (startValueEnumerator.MoveNext() || actualContinuationsEnumerator.MoveNext() || predictedContinuationsEnumerator.MoveNext())) {
-        throw new ArgumentException("Number of elements in startValues, actualContinuations and estimatedValues predictedContinuations doesn't match.");
-      } else {
-        errorState = calculator.ErrorState;
-        return calculator.WeightedDirectionalSymmetry;
-      }
-    }
-  }
-}
