Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs	(revision 5894)
@@ -84,5 +84,7 @@
       var classifier = new SymbolicDiscriminantFunctionClassificationModel(tree, interpreter);
       classifier.SetThresholdsAndClassValues(thresholds, classValues);
-      double originalAccuracy = OnlineAccuracyEvaluator.Calculate(targetClassValues, classifier.GetEstimatedClassValues(dataset, rows));
+      OnlineEvaluatorError errorState;
+      double originalAccuracy = OnlineAccuracyEvaluator.Calculate(targetClassValues, classifier.GetEstimatedClassValues(dataset, rows), out errorState);
+      if (errorState != OnlineEvaluatorError.None) originalAccuracy = 0.0;
 
       foreach (ISymbolicExpressionTreeNode node in nodes) {
@@ -97,5 +99,6 @@
         classifier = new SymbolicDiscriminantFunctionClassificationModel(tree, interpreter);
         classifier.SetThresholdsAndClassValues(thresholds, classValues);
-        double newAccuracy = OnlineAccuracyEvaluator.Calculate(targetClassValues, classifier.GetEstimatedClassValues(dataset, rows));
+        double newAccuracy = OnlineAccuracyEvaluator.Calculate(targetClassValues, classifier.GetEstimatedClassValues(dataset, rows), out errorState);
+        if (errorState != OnlineEvaluatorError.None) newAccuracy = 0.0;
 
         // impact = 0 if no change
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5894)
@@ -58,5 +58,7 @@
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
+      OnlineEvaluatorError errorState;
+      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) mse = double.NaN;
       return new double[2] { mse, solution.Length };
     }
@@ -72,5 +74,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return quality;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5894)
@@ -37,6 +37,9 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
-      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues);
-      return new double[] { double.IsNaN(r2) ? 0.0 : r2, solution.Length };
+      OnlineEvaluatorError errorState;
+      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) r2 = 0.0;
+      return new double[] { r2, solution.Length };
+
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveBoundedMeanSquaredErrorEvaluator.cs	(revision 5894)
@@ -63,5 +63,4 @@
       IEnumerator<double> originalEnumerator = originalValues.GetEnumerator();
       IEnumerator<double> estimatedEnumerator = estimatedValues.GetEnumerator();
-      OnlineMeanSquaredErrorEvaluator mseEvaluator = new OnlineMeanSquaredErrorEvaluator();
       double errorSum = 0.0;
       int n = 0;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5894)
@@ -58,5 +58,8 @@
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      return OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
+      OnlineEvaluatorError errorState;
+      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return double.NaN;
+      else return mse;
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5894)
@@ -58,6 +58,8 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
-      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues);
-      return double.IsNaN(r2) ? 0.0 : r2;
+      OnlineEvaluatorError errorState;
+      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return 0.0;
+      else return r2;
     }
 
@@ -72,5 +74,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return r2;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs	(revision 5894)
@@ -124,5 +124,7 @@
       double alpha;
       double beta;
-      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out alpha, out beta);
+      OnlineEvaluatorError errorState;
+      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out alpha, out beta, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return;
 
       ConstantTreeNode alphaTreeNode = null;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 5894)
@@ -78,6 +78,7 @@
         .ToArray();
       var targetValues = dataset.GetEnumeratedVariableValues(targetVariable, rows);
-
-      double originalR2 = OnlinePearsonsRSquaredEvaluator.Calculate(targetValues, originalOutput);
+      OnlineEvaluatorError errorState;
+      double originalR2 = OnlinePearsonsRSquaredEvaluator.Calculate(targetValues, originalOutput, out errorState);
+      if (errorState != OnlineEvaluatorError.None) originalR2 = 0.0;
 
       foreach (ISymbolicExpressionTreeNode node in nodes) {
@@ -87,5 +88,6 @@
         SwitchNode(parent, node, replacementNode);
         var newOutput = interpreter.GetSymbolicExpressionTreeValues(tree, dataset, rows);
-        double newR2 = OnlinePearsonsRSquaredEvaluator.Calculate(targetValues, newOutput);
+        double newR2 = OnlinePearsonsRSquaredEvaluator.Calculate(targetValues, newOutput, out errorState);
+        if (errorState != OnlineEvaluatorError.None) newR2 = 0.0;
 
         // impact = 0 if no change
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5894)
@@ -58,5 +58,7 @@
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
+      OnlineEvaluatorError errorState;
+      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) mse = double.NaN;
       return new double[2] { mse, solution.Length };
     }
@@ -72,5 +74,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return quality;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5894)
@@ -58,6 +58,8 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
-      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues);
-      return new double[] { double.IsNaN(r2) ? 0.0 : r2, solution.Length };
+      OnlineEvaluatorError errorState;
+      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) r2 = 0.0;
+      return new double[] { r2, solution.Length };
     }
 
@@ -72,5 +74,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return quality;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5894)
@@ -60,5 +60,8 @@
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      return OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
+      OnlineEvaluatorError errorState;
+      double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return double.NaN;
+      else return mse;
     }
 
@@ -74,5 +77,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return mse;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5894)
@@ -60,6 +60,8 @@
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
-      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues);
-      return double.IsNaN(r2) ? 0.0 : r2;
+      OnlineEvaluatorError errorState;
+      double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedValues, originalValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return 0.0;
+      else return r2;
     }
 
@@ -74,5 +76,5 @@
       SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
       EstimationLimitsParameter.ExecutionContext = null;
-      EvaluatedNodesParameter.ExecutionContext = null; 
+      EvaluatedNodesParameter.ExecutionContext = null;
 
       return r2;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 5894)
@@ -75,5 +75,7 @@
       double alpha;
       double beta;
-      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out alpha, out beta);
+      OnlineEvaluatorError errorState;
+      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out alpha, out beta, out errorState);
+      if (errorState != OnlineEvaluatorError.None) return;
 
       ConstantTreeNode alphaTreeNode = null;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 5894)
@@ -208,12 +208,16 @@
           var variableTreeNode = instr.dynamicNode as VariableTreeNode;
           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableTreeNode.VariableName);
-          code[i] = instr;
+          instr.dArg0 = variableTreeNode.Weight;
         } else if (instr.opCode == OpCodes.LagVariable) {
           var variableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableTreeNode.VariableName);
-          code[i] = instr;
+          instr.dArg0 = variableTreeNode.Weight;
         } else if (instr.opCode == OpCodes.VariableCondition) {
           var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
           instr.iArg0 = (ushort)dataset.GetVariableIndex(variableConditionTreeNode.VariableName);
+          instr.dArg0 = variableConditionTreeNode.Threshold;
+        } else if (instr.opCode == OpCodes.Constant) {
+          var constTreeNode = instr.dynamicNode as ConstantTreeNode;
+          instr.dArg0 = constTreeNode.Value;
         }
       }
@@ -408,6 +412,5 @@
           }
         case OpCodes.Variable: {
-            var variableTreeNode = currentInstr.dynamicNode as VariableTreeNode;
-            return dataset[row, currentInstr.iArg0] * variableTreeNode.Weight;
+            return dataset[row, currentInstr.iArg0] * currentInstr.dArg0;
           }
         case OpCodes.LagVariable: {
@@ -415,9 +418,8 @@
             int actualRow = row + laggedVariableTreeNode.Lag;
             if (actualRow < 0 || actualRow >= dataset.Rows) throw new ArgumentException("Out of range access to dataset row: " + row);
-            return dataset[actualRow, currentInstr.iArg0] * laggedVariableTreeNode.Weight;
+            return dataset[actualRow, currentInstr.iArg0] * currentInstr.dArg0;
           }
         case OpCodes.Constant: {
-            var constTreeNode = currentInstr.dynamicNode as ConstantTreeNode;
-            return constTreeNode.Value;
+            return currentInstr.dArg0;
           }
 
@@ -427,5 +429,5 @@
             var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
             double variableValue = dataset[row, currentInstr.iArg0];
-            double x = variableValue - variableConditionTreeNode.Threshold;
+            double x = variableValue - currentInstr.dArg0;
             double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 5894)
@@ -85,6 +85,9 @@
       IEnumerable<double> originalTestClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
 
-      double trainingAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTrainingClassValues, originalTrainingClassValues);
-      double testAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTestClassValues, originalTestClassValues);
+      OnlineEvaluatorError errorState;
+      double trainingAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTrainingClassValues, originalTrainingClassValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) trainingAccuracy = double.NaN;
+      double testAccuracy = OnlineAccuracyEvaluator.Calculate(estimatedTestClassValues, originalTestClassValues, out errorState);
+      if (errorState != OnlineEvaluatorError.None) testAccuracy = double.NaN;
 
       TrainingAccuracy = trainingAccuracy;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 5894)
@@ -105,13 +105,14 @@
       IEnumerable<double> originalTestValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
 
-      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
-      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
-      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
-      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues);
+      OnlineEvaluatorError errorState;
+      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
+      TrainingMeanSquaredError = errorState == OnlineEvaluatorError.None ? trainingMSE : double.NaN;
+      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
+      TestMeanSquaredError = errorState == OnlineEvaluatorError.None ? testMSE : double.NaN;
 
-      TrainingMeanSquaredError = trainingMSE;
-      TestMeanSquaredError = testMSE;
-      TrainingRSquared = trainingR2;
-      TestRSquared = testR2;
+      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
+      TrainingRSquared = errorState == OnlineEvaluatorError.None ? trainingR2 : double.NaN;
+      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
+      TestRSquared = errorState == OnlineEvaluatorError.None ? testR2 : double.NaN;
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/NormalDistributionCutPointsThresholdCalculator.cs	(revision 5894)
@@ -64,7 +64,11 @@
         double classValue = group.Key;
         double mean, variance;
-        OnlineMeanAndVarianceCalculator.Calculate(estimatedClassValues, out mean, out variance);
-        classMean[classValue] = mean;
-        classStdDev[classValue] = Math.Sqrt(variance);
+        OnlineEvaluatorError meanErrorState, varianceErrorState;
+        OnlineMeanAndVarianceCalculator.Calculate(estimatedClassValues, out mean, out variance, out meanErrorState, out varianceErrorState);
+
+        if (meanErrorState == OnlineEvaluatorError.None && varianceErrorState == OnlineEvaluatorError.None) {
+          classMean[classValue] = mean;
+          classStdDev[classValue] = Math.Sqrt(variance);
+        }
       }
       double[] originalClasses = classMean.Keys.OrderBy(x => x).ToArray();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 5894)
@@ -114,17 +114,19 @@
       IEnumerable<double> originalTestValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
 
-      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
-      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
-      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
-      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues);
-      double trainingRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues);
-      double testRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTestValues, originalTestValues);
+      OnlineEvaluatorError errorState;
+      double trainingMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
+      TrainingMeanSquaredError = errorState == OnlineEvaluatorError.None ? trainingMSE : double.NaN;
+      double testMSE = OnlineMeanSquaredErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
+      TestMeanSquaredError = errorState == OnlineEvaluatorError.None ? testMSE : double.NaN;
 
-      TrainingMeanSquaredError = trainingMSE;
-      TestMeanSquaredError = testMSE;
-      TrainingRSquared = trainingR2;
-      TestRSquared = testR2;
-      TrainingRelativeError = trainingRelError;
-      TestRelativeError = testRelError;
+      double trainingR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
+      TrainingRSquared = errorState == OnlineEvaluatorError.None ? trainingR2 : double.NaN;
+      double testR2 = OnlinePearsonsRSquaredEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
+      TestRSquared = errorState == OnlineEvaluatorError.None ? testR2 : double.NaN;
+
+      double trainingRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTrainingValues, originalTrainingValues, out errorState);
+      TrainingRelativeError = errorState == OnlineEvaluatorError.None ? trainingRelError : double.NaN;
+      double testRelError = OnlineMeanAbsolutePercentageErrorEvaluator.Calculate(estimatedTestValues, originalTestValues, out errorState);
+      TestRelativeError = errorState == OnlineEvaluatorError.None ? testRelError : double.NaN;
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineEvaluator.cs	(revision 5894)
@@ -21,6 +21,23 @@
 
 
+using System;
 namespace HeuristicLab.Problems.DataAnalysis {
+  [Flags]
+  public enum OnlineEvaluatorError { 
+    /// <summary>
+    /// No error occurred
+    /// </summary>
+    None = 0, 
+    /// <summary>
+    /// An invalid value has been added (often +/- Infinity and NaN are invalid values)
+    /// </summary>
+    InvalidValueAdded = 1, 
+    /// <summary>
+    /// The number of elements added to the evaluator is not sufficient to calculate the result value
+    /// </summary>
+    InsufficientElementsAdded = 2
+  }
   public interface IOnlineEvaluator {
+    OnlineEvaluatorError ErrorState { get; }
     double Value { get; }
     void Reset();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineAccuracyEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineAccuracyEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineAccuracyEvaluator.cs	(revision 5894)
@@ -31,8 +31,5 @@
     public double Accuracy {
       get {
-        if (n < 1)
-          throw new InvalidOperationException("No elements");
-        else
-          return correctlyClassified / (double)n;
+        return correctlyClassified / (double)n;
       }
     }
@@ -43,4 +40,8 @@
 
     #region IOnlineEvaluator Members
+    private OnlineEvaluatorError errorState;
+    public OnlineEvaluatorError ErrorState {
+      get { return errorState; }
+    }
     public double Value {
       get { return Accuracy; }
@@ -49,18 +50,23 @@
       n = 0;
       correctlyClassified = 0;
+      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     }
 
     public void Add(double original, double estimated) {
-      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
-          double.IsNaN(original) || double.IsInfinity(original)) {
-        throw new ArgumentException("Accuracy is not defined for NaN or infinity elements");
-      } else {
-        if (original.IsAlmost(estimated)) correctlyClassified++;
+      // ignore cases where original is NaN completly 
+      if (!double.IsNaN(original)) {
+        // increment number of observed samples
         n++;
+        if (original.IsAlmost(estimated)) {
+          // original = estimated = +Inf counts as correctly classified
+          // original = estimated = -Inf counts as correctly classified
+          correctlyClassified++;
+        }
+        errorState = OnlineEvaluatorError.None; // number of (non-NaN) samples >= 1
       }
     }
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -78,4 +84,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = accuracyEvaluator.ErrorState;
         return accuracyEvaluator.Accuracy;
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineCovarianceEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineCovarianceEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineCovarianceEvaluator.cs	(revision 5894)
@@ -39,4 +39,8 @@
 
     #region IOnlineEvaluator Members
+    private OnlineEvaluatorError errorState;
+    public OnlineEvaluatorError ErrorState {
+      get { return errorState; }
+    }
     public double Value {
       get { return Covariance; }
@@ -47,13 +51,14 @@
       originalMean = 0.0;
       estimatedMean = 0.0;
+      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     }
 
     public void Add(double original, double estimated) {
-      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
-          double.IsNaN(original) || double.IsInfinity(original) ||
-         double.IsNaN(Cn)) {
-        Cn = double.NaN;
-      } else {
+      if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original)) {
+        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
+      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
         n++;
+        errorState = OnlineEvaluatorError.None;        // n >= 1
+
         // online calculation of tMean
         originalMean = originalMean + (original - originalMean) / n;
@@ -67,5 +72,5 @@
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -83,4 +88,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = covarianceEvaluator.ErrorState;
         return covarianceEvaluator.Covariance;
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs	(revision 5894)
@@ -32,8 +32,5 @@
     public double Alpha {
       get {
-        if (cnt < 2)
-          return 0;
-        else
-          return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
+        return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
       }
     }
@@ -44,10 +41,15 @@
     public double Beta {
       get {
-        if (cnt < 2)
-          return 1;
-        else if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
+        if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
           return 1;
         else
           return originalTargetCovarianceEvaluator.Covariance / originalMeanAndVarianceCalculator.PopulationVariance;
+      }
+    }
+
+    public OnlineEvaluatorError ErrorState {
+      get {
+        return targetMeanCalculator.MeanErrorState | originalMeanAndVarianceCalculator.MeanErrorState |
+          originalMeanAndVarianceCalculator.PopulationVarianceErrorState | originalTargetCovarianceEvaluator.ErrorState;
       }
     }
@@ -94,5 +96,6 @@
     /// <param name="alpha">Additive constant for the linear scaling</param>
     /// <param name="beta">Multiplicative factor for the linear scaling</param>
-    public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta) {
+    /// <param name="errorState">Flag that indicates if errors occurred in the calculation of the linea scaling parameters.</param>
+    public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta, out OnlineEvaluatorError errorState) {
       OnlineLinearScalingParameterCalculator calculator = new OnlineLinearScalingParameterCalculator();
       IEnumerator<double> originalEnumerator = original.GetEnumerator();
@@ -110,4 +113,5 @@
         throw new ArgumentException("Number of elements in original and target enumeration do not match.");
       } else {
+        errorState = calculator.ErrorState;
         alpha = calculator.Alpha;
         beta = calculator.Beta;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs	(revision 5894)
@@ -40,4 +40,8 @@
 
     #region IOnlineEvaluator Members
+    private OnlineEvaluatorError errorState;
+    public OnlineEvaluatorError ErrorState {
+      get { return errorState; }
+    }
     public double Value {
       get { return MeanAbsolutePercentageError; }
@@ -46,4 +50,5 @@
       n = 0;
       sre = 0.0;
+      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     }
 
@@ -51,11 +56,10 @@
       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
           double.IsNaN(original) || double.IsInfinity(original) ||
-        double.IsNaN(sre)) {
-        sre = double.NaN;
-      } else {
-        if (!original.IsAlmost(0.0)) {
-          sre += Math.Abs((estimated - original) / original);
-          n++;
-        }
+        original.IsAlmost(0.0)) {
+        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
+      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
+        sre += Math.Abs((estimated - original) / original);
+        n++;
+        errorState = OnlineEvaluatorError.None; // n >= 1
       }
     }
@@ -63,5 +67,5 @@
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -79,4 +83,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = evaluator.ErrorState;
         return evaluator.MeanAbsolutePercentageError;
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAndVarianceCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAndVarianceCalculator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAndVarianceCalculator.cs	(revision 5894)
@@ -29,4 +29,9 @@
     private int n;
 
+    private OnlineEvaluatorError varianceErrorState;
+    public OnlineEvaluatorError VarianceErrorState {
+      get { return varianceErrorState; }
+    }
+
     public double Variance {
       get {
@@ -35,4 +40,8 @@
     }
 
+    private OnlineEvaluatorError errorState;
+    public OnlineEvaluatorError PopulationVarianceErrorState {
+      get { return errorState; }
+    }
     public double PopulationVariance {
       get {
@@ -41,4 +50,7 @@
     }
 
+    public OnlineEvaluatorError MeanErrorState {
+      get { return errorState; }
+    }
     public double Mean {
       get {
@@ -57,11 +69,13 @@
     public void Reset() {
       n = 0;
+      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
+      varianceErrorState = OnlineEvaluatorError.InsufficientElementsAdded;
     }
 
     public void Add(double x) {
-      if (double.IsNaN(x) || double.IsInfinity(x) || double.IsNaN(m_newM)) {
-        m_newM = double.NaN;
-        m_newS = double.NaN;
-      } else {
+      if (double.IsNaN(x) || double.IsInfinity(x)) {
+        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
+        varianceErrorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
+      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
         n++;
         // See Knuth TAOCP vol 2, 3rd edition, page 232
@@ -69,5 +83,7 @@
           m_oldM = m_newM = x;
           m_oldS = 0.0;
+          errorState = OnlineEvaluatorError.None; // n >= 1
         } else {
+          varianceErrorState = OnlineEvaluatorError.None; // n >= 1
           m_newM = m_oldM + (x - m_oldM) / n;
           m_newS = m_oldS + (x - m_oldM) * (x - m_newM);
@@ -80,5 +96,5 @@
     }
 
-    public static void Calculate(IEnumerable<double> x, out double mean, out double variance) {
+    public static void Calculate(IEnumerable<double> x, out double mean, out double variance, out OnlineEvaluatorError meanErrorState, out OnlineEvaluatorError varianceErrorState) {
       OnlineMeanAndVarianceCalculator meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator();
       foreach (double xi in x) {
@@ -87,4 +103,6 @@
       mean = meanAndVarianceCalculator.Mean;
       variance = meanAndVarianceCalculator.Variance;
+      meanErrorState = meanAndVarianceCalculator.MeanErrorState;
+      varianceErrorState = meanAndVarianceCalculator.VarianceErrorState;
     }
   }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanSquaredErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanSquaredErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanSquaredErrorEvaluator.cs	(revision 5894)
@@ -39,4 +39,8 @@
 
     #region IOnlineEvaluator Members
+    private OnlineEvaluatorError errorState;
+    public OnlineEvaluatorError ErrorState {
+      get { return errorState; }
+    }
     public double Value {
       get { return MeanSquaredError; }
@@ -45,20 +49,21 @@
       n = 0;
       sse = 0.0;
+      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     }
 
     public void Add(double original, double estimated) {
       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
-          double.IsNaN(original) || double.IsInfinity(original) ||
-        double.IsNaN(sse)) {
-        sse = double.NaN;
-      } else {
+          double.IsNaN(original) || double.IsInfinity(original)) {
+        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
+      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
         double error = estimated - original;
         sse += error * error;
         n++;
+        errorState = OnlineEvaluatorError.None; // n >= 1
       }
     }
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -76,4 +81,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = mseEvaluator.ErrorState;
         return mseEvaluator.MeanSquaredError;
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineNormalizedMeanSquaredErrorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineNormalizedMeanSquaredErrorEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineNormalizedMeanSquaredErrorEvaluator.cs	(revision 5894)
@@ -43,4 +43,7 @@
 
     #region IOnlineEvaluator Members
+    public OnlineEvaluatorError ErrorState {
+      get { return meanSquaredErrorCalculator.MeanErrorState | originalVarianceCalculator.VarianceErrorState; }
+    }
     public double Value {
       get { return NormalizedMeanSquaredError; }
@@ -60,5 +63,5 @@
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -76,4 +79,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = normalizedMSEEvaluator.ErrorState;
         return normalizedMSEEvaluator.NormalizedMeanSquaredError;
       }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlinePearsonsRSquaredEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlinePearsonsRSquaredEvaluator.cs	(revision 5893)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlinePearsonsRSquaredEvaluator.cs	(revision 5894)
@@ -46,4 +46,7 @@
 
     #region IOnlineEvaluator Members
+    public OnlineEvaluatorError ErrorState {
+      get { return covEvaluator.ErrorState | sxEvaluator.PopulationVarianceErrorState | syEvaluator.PopulationVarianceErrorState; }
+    }
     public double Value {
       get { return RSquared; }
@@ -64,5 +67,5 @@
     #endregion
 
-    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
+    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
       IEnumerator<double> firstEnumerator = first.GetEnumerator();
       IEnumerator<double> secondEnumerator = second.GetEnumerator();
@@ -80,4 +83,5 @@
         throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
       } else {
+        errorState = rSquaredEvaluator.ErrorState;
         return rSquaredEvaluator.RSquared;
       }
