Index: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 12279)
+++ stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 12636)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using HeuristicLab.Common;
@@ -39,6 +40,13 @@
     protected const string TrainingNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (training)";
     protected const string TestNormalizedMeanSquaredErrorResultName = "Normalized mean squared error (test)";
-    protected const string TrainingMeanErrorResultName = "Mean error (training)";
-    protected const string TestMeanErrorResultName = "Mean error (test)";
+    protected const string TrainingRootMeanSquaredErrorResultName = "Root mean squared error (training)";
+    protected const string TestRootMeanSquaredErrorResultName = "Root mean squared error (test)";
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.5
+    private const string TrainingMeanErrorResultName = "Mean error (training)";
+    private const string TestMeanErrorResultName = "Mean error (test)";
+    #endregion
+
 
     protected const string TrainingMeanSquaredErrorResultDescription = "Mean of squared errors of the model on the training partition";
@@ -52,6 +60,6 @@
     protected const string TrainingNormalizedMeanSquaredErrorResultDescription = "Normalized mean of squared errors of the model on the training partition";
     protected const string TestNormalizedMeanSquaredErrorResultDescription = "Normalized mean of squared errors of the model on the test partition";
-    protected const string TrainingMeanErrorResultDescription = "Mean of errors of the model on the training partition";
-    protected const string TestMeanErrorResultDescription = "Mean of errors of the model on the test partition";
+    protected const string TrainingRootMeanSquaredErrorResultDescription = "Root mean of squared errors of the model on the training partition";
+    protected const string TestRootMeanSquaredErrorResultDescription = "Root mean of squared errors of the model on the test partition";
 
     public new IRegressionModel Model {
@@ -111,12 +119,36 @@
       private set { ((DoubleValue)this[TestNormalizedMeanSquaredErrorResultName].Value).Value = value; }
     }
-    public double TrainingMeanError {
-      get { return ((DoubleValue)this[TrainingMeanErrorResultName].Value).Value; }
-      private set { ((DoubleValue)this[TrainingMeanErrorResultName].Value).Value = value; }
-    }
-    public double TestMeanError {
-      get { return ((DoubleValue)this[TestMeanErrorResultName].Value).Value; }
-      private set { ((DoubleValue)this[TestMeanErrorResultName].Value).Value = value; }
-    }
+    public double TrainingRootMeanSquaredError {
+      get { return ((DoubleValue)this[TrainingRootMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingRootMeanSquaredErrorResultName].Value).Value = value; }
+    }
+    public double TestRootMeanSquaredError {
+      get { return ((DoubleValue)this[TestRootMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestRootMeanSquaredErrorResultName].Value).Value = value; }
+    }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.5
+    private double TrainingMeanError {
+      get {
+        if (!ContainsKey(TrainingMeanErrorResultName)) return double.NaN;
+        return ((DoubleValue)this[TrainingMeanErrorResultName].Value).Value;
+      }
+      set {
+        if (ContainsKey(TrainingMeanErrorResultName))
+          ((DoubleValue)this[TrainingMeanErrorResultName].Value).Value = value;
+      }
+    }
+    private double TestMeanError {
+      get {
+        if (!ContainsKey(TestMeanErrorResultName)) return double.NaN;
+        return ((DoubleValue)this[TestMeanErrorResultName].Value).Value;
+      }
+      set {
+        if (ContainsKey(TestMeanErrorResultName))
+          ((DoubleValue)this[TestMeanErrorResultName].Value).Value = value;
+      }
+    }
+    #endregion
     #endregion
 
@@ -138,6 +170,6 @@
       Add(new Result(TrainingNormalizedMeanSquaredErrorResultName, TrainingNormalizedMeanSquaredErrorResultDescription, new DoubleValue()));
       Add(new Result(TestNormalizedMeanSquaredErrorResultName, TestNormalizedMeanSquaredErrorResultDescription, new DoubleValue()));
-      Add(new Result(TrainingMeanErrorResultName, TrainingMeanErrorResultDescription, new DoubleValue()));
-      Add(new Result(TestMeanErrorResultName, TestMeanErrorResultDescription, new DoubleValue()));
+      Add(new Result(TrainingRootMeanSquaredErrorResultName, TrainingRootMeanSquaredErrorResultDescription, new DoubleValue()));
+      Add(new Result(TestRootMeanSquaredErrorResultName, TestRootMeanSquaredErrorResultDescription, new DoubleValue()));
     }
 
@@ -145,7 +177,5 @@
     private void AfterDeserialization() {
       // BackwardsCompatibility3.4
-
       #region Backwards compatible code, remove with 3.5
-
       if (!ContainsKey(TrainingMeanAbsoluteErrorResultName)) {
         OnlineCalculatorError errorState;
@@ -162,15 +192,16 @@
       }
 
-      if (!ContainsKey(TrainingMeanErrorResultName)) {
-        OnlineCalculatorError errorState;
-        Add(new Result(TrainingMeanErrorResultName, "Mean of errors of the model on the training partition", new DoubleValue()));
-        double trainingME = OnlineMeanErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
-        TrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
-      }
-      if (!ContainsKey(TestMeanErrorResultName)) {
-        OnlineCalculatorError errorState;
-        Add(new Result(TestMeanErrorResultName, "Mean of errors of the model on the test partition", new DoubleValue()));
-        double testME = OnlineMeanErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
-        TestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
+      if (!ContainsKey(TrainingRootMeanSquaredErrorResultName)) {
+        OnlineCalculatorError errorState;
+        Add(new Result(TrainingRootMeanSquaredErrorResultName, TrainingRootMeanSquaredErrorResultDescription, new DoubleValue()));
+        double trainingMSE = OnlineMeanSquaredErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
+        TrainingRootMeanSquaredError = errorState == OnlineCalculatorError.None ? Math.Sqrt(trainingMSE) : double.NaN;
+      }
+
+      if (!ContainsKey(TestRootMeanSquaredErrorResultName)) {
+        OnlineCalculatorError errorState;
+        Add(new Result(TestRootMeanSquaredErrorResultName, TestRootMeanSquaredErrorResultDescription, new DoubleValue()));
+        double testMSE = OnlineMeanSquaredErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
+        TestRootMeanSquaredError = errorState == OnlineCalculatorError.None ? Math.Sqrt(testMSE) : double.NaN;
       }
       #endregion
@@ -213,8 +244,18 @@
       TestNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? testNMSE : double.NaN;
 
-      double trainingME = OnlineMeanErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
-      TrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
-      double testME = OnlineMeanErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
-      TestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
+      TrainingRootMeanSquaredError = Math.Sqrt(TrainingMeanSquaredError);
+      TestRootMeanSquaredError = Math.Sqrt(TestMeanSquaredError);
+
+      // BackwardsCompatibility3.3
+      #region Backwards compatible code, remove with 3.5
+      if (ContainsKey(TrainingMeanErrorResultName)) {
+        double trainingME = OnlineMeanErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
+        TrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
+      }
+      if (ContainsKey(TestMeanErrorResultName)) {
+        double testME = OnlineMeanErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
+        TestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
+      }
+      #endregion
     }
   }
