Index: branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionErrorCharacteristicsCurveView.cs
===================================================================
--- branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionErrorCharacteristicsCurveView.cs	(revision 17990)
+++ branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionErrorCharacteristicsCurveView.cs	(revision 17991)
@@ -26,4 +26,5 @@
 using HeuristicLab.Algorithms.DataAnalysis;
 using HeuristicLab.MainForm;
+using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis.Views;
 
@@ -43,5 +44,4 @@
     private IRegressionSolution CreateLinearRegressionSolution() {
       if (Content == null) throw new InvalidOperationException();
-      double rmse, cvRmsError;
       var problemData = (IRegressionProblemData)ProblemData.Clone();
       if (!problemData.TrainingIndices.Any()) return null; // don't create an LR model if the problem does not have a training set (e.g. loaded into an existing model)
@@ -87,7 +87,14 @@
       newProblemData.TestPartition.End = problemData.TestPartition.End;
 
-      var solution = LinearRegression.CreateLinearRegressionSolution(newProblemData, out rmse, out cvRmsError);
-      solution.Name = "Baseline (linear subset)";
-      return solution;
+      try {
+        var solution = LinearRegression.CreateSolution(newProblemData, out _, out _, out _);
+        solution.Name = "Baseline (linear subset)";
+        return solution;
+      } catch (NotSupportedException e) {
+        ErrorHandling.ShowErrorDialog("Could not create a linear regression solution.", e);
+      } catch (ArgumentException e) {
+        ErrorHandling.ShowErrorDialog("Could not create a linear regression solution.", e);
+      }
+      return null;
     }
 
@@ -99,5 +106,6 @@
       if (Content.Model.SymbolicExpressionTree.IterateNodesPrefix().OfType<LaggedVariableTreeNode>().Any()) yield break;
 
-      yield return CreateLinearRegressionSolution();
+      var linearRegressionSolution = CreateLinearRegressionSolution();
+      if (linearRegressionSolution != null) yield return linearRegressionSolution;
     }
   }
Index: branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs
===================================================================
--- branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 17990)
+++ branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 17991)
@@ -29,4 +29,5 @@
 using HeuristicLab.MainForm;
 using HeuristicLab.Optimization;
+using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.DataAnalysis.Views {
@@ -74,5 +75,5 @@
     }
 
-    private readonly IList<IRegressionSolution> solutions = new List<IRegressionSolution>();
+    private readonly List<IRegressionSolution> solutions = new List<IRegressionSolution>();
     public IEnumerable<IRegressionSolution> Solutions {
       get { return solutions.AsEnumerable(); }
@@ -103,8 +104,5 @@
         solutions.Clear(); // remove all
         solutions.Add(Content); // re-add the first solution
-        // and recalculate all other solutions
-        foreach (var sol in CreateBaselineSolutions()) {
-          solutions.Add(sol);
-        }
+        solutions.AddRange(CreateBaselineSolutions());
         UpdateChart();
       }
@@ -116,8 +114,5 @@
         solutions.Clear(); // remove all
         solutions.Add(Content); // re-add the first solution
-        // and recalculate all other solutions
-        foreach (var sol in CreateBaselineSolutions()) {
-          solutions.Add(sol);
-        }
+        solutions.AddRange(CreateBaselineSolutions());
         UpdateChart();
       }
@@ -249,7 +244,9 @@
     protected virtual List<double> GetResiduals(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues) {
       switch (residualComboBox.SelectedItem.ToString()) {
-        case "Absolute error": return originalValues.Zip(estimatedValues, (x, y) => Math.Abs(x - y))
+        case "Absolute error":
+          return originalValues.Zip(estimatedValues, (x, y) => Math.Abs(x - y))
             .Where(r => !double.IsNaN(r) && !double.IsInfinity(r)).ToList();
-        case "Squared error": return originalValues.Zip(estimatedValues, (x, y) => (x - y) * (x - y))
+        case "Squared error":
+          return originalValues.Zip(estimatedValues, (x, y) => (x - y) * (x - y))
             .Where(r => !double.IsNaN(r) && !double.IsInfinity(r)).ToList();
         case "Relative error":
@@ -289,9 +286,14 @@
 
     protected virtual IEnumerable<IRegressionSolution> CreateBaselineSolutions() {
-      yield return CreateConstantSolution();
-      yield return CreateLinearSolution();
+      var constantSolution = CreateConstantSolution();
+      if (constantSolution != null) yield return CreateConstantSolution();
+
+      var linearRegressionSolution = CreateLinearSolution();
+      if (linearRegressionSolution != null) yield return CreateLinearSolution();
     }
 
     private IRegressionSolution CreateConstantSolution() {
+      if (!ProblemData.TrainingIndices.Any()) return null;
+
       double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).Average();
       var model = new ConstantModel(averageTrainingTarget, ProblemData.TargetVariable);
@@ -301,8 +303,14 @@
     }
     private IRegressionSolution CreateLinearSolution() {
-      double rmsError, cvRmsError;
-      var solution = LinearRegression.CreateLinearRegressionSolution((IRegressionProblemData)ProblemData.Clone(), out rmsError, out cvRmsError);
-      solution.Name = "Baseline (linear)";
-      return solution;
+      try {
+        var solution = LinearRegression.CreateSolution((IRegressionProblemData)ProblemData.Clone(), out _, out _, out _);
+        solution.Name = "Baseline (linear)";
+        return solution;
+      } catch (NotSupportedException e) {
+        ErrorHandling.ShowErrorDialog("Could not create a linear regression solution.", e);
+      } catch (ArgumentException e) {
+        ErrorHandling.ShowErrorDialog("Could not create a linear regression solution.", e);
+      }
+      return null;
     }
 
Index: branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.DecisionTrees/3.4/LeafTypes/LinearLeaf.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.DecisionTrees/3.4/LeafTypes/LinearLeaf.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.DecisionTrees/3.4/LeafTypes/LinearLeaf.cs	(revision 17991)
@@ -50,5 +50,5 @@
       double rmse, cvRmse;
       numberOfParameters = pd.AllowedInputVariables.Count() + 1;
-      var res = LinearRegression.CreateSolution(pd, out rmse, out cvRmse);
+      var res = LinearRegression.CreateSolution(pd, out rmse, out cvRmse, out _);
       return res.Model;
     }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.Glmnet/3.4/ElasticNetLinearRegression.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.Glmnet/3.4/ElasticNetLinearRegression.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis.Glmnet/3.4/ElasticNetLinearRegression.cs	(revision 17991)
@@ -34,4 +34,5 @@
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+using HeuristicLab.Analysis.Statistics;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Glmnet {
@@ -88,5 +89,5 @@
     }
 
-  private void CreateSolution(double lambda) {
+    private void CreateSolution(double lambda) {
       double trainNMSE;
       double testNMSE;
@@ -97,4 +98,15 @@
       var solution = CreateSymbolicSolution(coeff, Problem.ProblemData);
       Results.Add(new Result(solution.Name, solution.Description, solution));
+
+      var xy = Problem.ProblemData.Dataset.ToArray(Problem.ProblemData.AllowedInputVariables.Concat(new[] { Problem.ProblemData.TargetVariable }), Problem.ProblemData.TrainingIndices);
+      // prepare xy for calculation of parameter statistics
+      // the last coefficient is the offset
+      var resid = new double[xy.GetLength(0)];
+      for (int r = 0; r < xy.GetLength(0); r++) {
+        resid[r] = xy[r, coeff.Length - 1] - coeff[coeff.Length - 1];
+        xy[r, coeff.Length - 1] = 1.0;
+      }
+      var statistics = Statistics.CalculateParameterStatistics(xy, coeff, resid);
+      Results.AddOrUpdateResult("Statistics", statistics.AsResultCollection(Problem.ProblemData.AllowedInputVariables.Concat(new string[] { "<const>" })));
     }
 
Index: branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 17991)
@@ -32,4 +32,6 @@
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+using HeuristicLab.Analysis;
+using HeuristicLab.Analysis.Statistics;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -66,7 +68,7 @@
       // as the calculation of prediction intervals.
       // There is no clean way to implement the new model class for LR as a symbolic model.
-      var solution = CreateSolution(Problem.ProblemData, out rmsError, out cvRmsError);
+      var solution = CreateSolution(Problem.ProblemData, out rmsError, out cvRmsError, out _);
 #pragma warning disable 168, 3021
-      var symbolicSolution = CreateLinearRegressionSolution(Problem.ProblemData, out rmsError, out cvRmsError);
+      var symbolicSolution = CreateLinearRegressionSolution(Problem.ProblemData, out rmsError, out cvRmsError, out var statistics);
 #pragma warning restore 168, 3021
       Results.Add(new Result(SolutionResultName, "The linear regression solution.", symbolicSolution));
@@ -75,8 +77,12 @@
       Results.Add(new Result("Root mean square error", "The root of the mean of squared errors of the linear regression solution on the training set.", new DoubleValue(rmsError)));
       Results.Add(new Result("Estimated root mean square error (cross-validation)", "The estimated root of the mean of squared errors of the linear regression solution via cross validation.", new DoubleValue(cvRmsError)));
+
+      var predictorNames = Problem.ProblemData.AllowedInputVariables.Concat(new string[] { "<const>" }).ToArray();
+      Results.AddOrUpdateResult("Statistics", statistics.AsResultCollection(predictorNames));
+
     }
 
     [Obsolete("Use CreateSolution() instead")]
-    public static ISymbolicRegressionSolution CreateLinearRegressionSolution(IRegressionProblemData problemData, out double rmsError, out double cvRmsError) {
+    public static ISymbolicRegressionSolution CreateLinearRegressionSolution(IRegressionProblemData problemData, out double rmsError, out double cvRmsError, out Statistics statistics) {
       IEnumerable<string> doubleVariables;
       IEnumerable<KeyValuePair<string, IEnumerable<string>>> factorVariables;
@@ -84,11 +90,8 @@
       PrepareData(problemData, out inputMatrix, out doubleVariables, out factorVariables);
 
-      alglib.linearmodel lm = new alglib.linearmodel();
-      alglib.lrreport ar = new alglib.lrreport();
       int nRows = inputMatrix.GetLength(0);
       int nFeatures = inputMatrix.GetLength(1) - 1;
 
-      int retVal = 1;
-      alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar);
+      alglib.lrbuild(inputMatrix, nRows, nFeatures, out int retVal, out var lm, out var ar);
       if (retVal != 1) throw new ArgumentException("Error in calculation of linear regression solution");
       rmsError = ar.rmserror;
@@ -98,4 +101,13 @@
       alglib.lrunpack(lm, out coefficients, out nFeatures);
 
+      // prepare inputmatrix (which has y as last column) for calculation of parameter statistics
+      // the last coefficient is the offset
+      var resid = new double[nRows];
+      for (int r = 0; r < nRows; r++) {
+        resid[r] = inputMatrix[r, nFeatures] - coefficients[nFeatures];
+        inputMatrix[r, nFeatures] = 1.0;
+      }
+      statistics = Statistics.CalculateParameterStatistics(inputMatrix, coefficients, resid);
+
       int nFactorCoeff = factorVariables.Sum(kvp => kvp.Value.Count());
       int nVarCoeff = doubleVariables.Count();
@@ -104,5 +116,7 @@
         @const: coefficients[nFeatures]);
 
-      SymbolicRegressionSolution solution = new SymbolicRegressionSolution(new SymbolicRegressionModel(problemData.TargetVariable, tree, new SymbolicDataAnalysisExpressionTreeLinearInterpreter()), (IRegressionProblemData)problemData.Clone());
+      SymbolicRegressionSolution solution = new SymbolicRegressionSolution(
+        new SymbolicRegressionModel(problemData.TargetVariable, tree, new SymbolicDataAnalysisExpressionTreeLinearInterpreter(), parameterCovariance: statistics.CovMx), 
+        (IRegressionProblemData)problemData.Clone());
       solution.Model.Name = "Linear Regression Model";
       solution.Name = "Linear Regression Solution";
@@ -110,5 +124,5 @@
     }
 
-    public static IRegressionSolution CreateSolution(IRegressionProblemData problemData, out double rmsError, out double cvRmsError) {
+    public static IRegressionSolution CreateSolution(IRegressionProblemData problemData, out double rmsError, out double cvRmsError, out Statistics statistics) {
       IEnumerable<string> doubleVariables;
       IEnumerable<KeyValuePair<string, IEnumerable<string>>> factorVariables;
@@ -116,11 +130,8 @@
       PrepareData(problemData, out inputMatrix, out doubleVariables, out factorVariables);
 
-      alglib.linearmodel lm = new alglib.linearmodel();
-      alglib.lrreport ar = new alglib.lrreport();
       int nRows = inputMatrix.GetLength(0);
       int nFeatures = inputMatrix.GetLength(1) - 1;
 
-      int retVal = 1;
-      alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar);
+      alglib.lrbuild(inputMatrix, nRows, nFeatures, out int retVal, out var lm, out var ar);
       if (retVal != 1) throw new ArgumentException("Error in calculation of linear regression solution");
       rmsError = ar.rmserror;
@@ -129,10 +140,16 @@
       // get parameters of the model
       double[] w;
-      int nVars;
-      alglib.lrunpack(lm, out w, out nVars);
+      alglib.lrunpack(lm, out w, out _);
+
+      // prepare inputmatrix (which has y as last column) for calculation of parameter statistics
+      // the last coefficient is the offset
+      var resid = new double[nRows];
+      for (int r = 0; r < nRows; r++) {
+        resid[r] = inputMatrix[r, nFeatures] - w[nFeatures];
+        inputMatrix[r, nFeatures] = 1.0;
+      }
+      statistics = Statistics.CalculateParameterStatistics(inputMatrix, w, resid);
 
       // ar.c is the covariation matrix,  array[0..NVars,0..NVars].
-      // C[i, j] = Cov(A[i], A[j])
-
       var solution = new LinearRegressionModel(w, ar.c, cvRmsError, problemData.TargetVariable, doubleVariables, factorVariables)
         .CreateRegressionSolution((IRegressionProblemData)problemData.Clone());
Index: branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/HeuristicLab.Analysis-3.3.csproj	(revision 17991)
@@ -173,4 +173,5 @@
     <Compile Include="Statistics\Fitting\ExpFitting.cs" />
     <Compile Include="Statistics\Fitting\IFitting.cs" />
+    <Compile Include="Statistics\Fitting\Statistics.cs" />
     <Compile Include="Statistics\KruskalWallisTest.cs" />
     <Compile Include="Statistics\Fitting\LinearLeastSquaresFitting.cs" />
Index: branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/Statistics/Fitting/Statistics.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/Statistics/Fitting/Statistics.cs	(revision 17991)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Analysis/3.3/Statistics/Fitting/Statistics.cs	(revision 17991)
@@ -0,0 +1,221 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Analysis.Statistics {
+  // C# code is derived from MATLAB code published with
+  //   Dianne P. O'Leary and Bert W. Rust,
+  //   Variable Projection for Nonlinear Least Squares Problems,
+  //   US National Inst. of Standards and Technology, 2010.
+  public class Statistics {
+    public double[] coeff;
+    /// <summary>
+    /// square-root of weighted residual norm squared divided by number of degrees of freedom.
+    /// </summary>
+    public double sigma;
+    /// <summary>
+    // weighted residual norm divided by the number of degrees of freedom.
+    /// </summary>
+    public double RMS;
+    /// <summary>
+    /// covariance matrix CovMx, which is sigma ^ 2 times the inverse of H'*H, where H = W *[dCoeff] contains the partial derivatives of wresid with respect to the parameters in coeff.
+    /// </summary>
+    public double[,] CovMx;
+    /// <summary>
+    /// estimated correlation matrix (numParam) x (numParam) for the parameters. 
+    /// </summary>
+    public double[,] CorMx;
+    /// <summary>
+    ///  Parameter standard deviation. The k-th element is the square root of the k-th main diagonal element of CovMx.
+    /// </summary>
+    public double[] std_param;
+    /// <summary>
+    ///  parameter estimates divided by their standard deviations.
+    /// </summary>
+    public double[] t_ratio;
+    /// <summary>
+    /// p-Value for the t_ratio (two-tailed)
+    /// </summary>
+    public double[] p_value;
+    /// <summary>
+    /// The k-th component is the k-th component of the weighted residual, divided by its standard deviation.
+    /// </summary>
+    public double[] standardized_wresid;
+
+    public ResultCollection AsResultCollection(IEnumerable<string> predictorNames) {
+      var statResults = new ResultCollection();
+      statResults.Add(new Result("Sigma", "Square-root of weighted residual norm squared divided by number of degrees of freedom.", new DoubleValue(sigma)));
+      statResults.Add(new Result("RMS", "weighted residual norm divided by the number of degrees of freedom.", new DoubleValue(RMS)));
+      statResults.Add(new Result("Correlations", "Correlation matrix of parameters", new DoubleMatrix(CorMx, predictorNames, predictorNames)));
+      statResults.Add(new Result("Covariance", "Covariance matrix of parameters", new DoubleMatrix(CovMx, predictorNames, predictorNames)));
+
+      var m = new string[coeff.Length, 4];
+      for (int i = 0; i < coeff.Length; i++) {
+        m[i, 0] = coeff[i].ToString("g4");
+        m[i, 1] = std_param[i].ToString("g4");
+        m[i, 2] = t_ratio[i].ToString("g4");
+        m[i, 3] = p_value[i].ToString("g4");
+      }
+      var paramStats = new StringMatrix(m) { ColumnNames = new string[] { "Value", "St.dev", "t-ratio", "p-value" }, RowNames = predictorNames };
+      paramStats.SortableView = true;
+      statResults.Add(new Result("Parameter statistics", "", paramStats));
+
+      var wres = new DataTable("Standardized weighted residuals");
+      wres.Rows.Add(new DataRow("Standarized weighted residuals", string.Empty, standardized_wresid));
+      statResults.Add(new Result("Standardized weighted residuals", "The the weighted residuals, divided by their standard deviations", wres));
+
+      return statResults;
+    }
+
+    public static Statistics CalculateLinearModelStatistics(double[,] jac, double[] coeff, double[] resid, double[] weight = null) {
+      return CalculateParameterStatistics(jac, coeff, resid, weight);
+    }
+
+    // see http://sia.webpopix.org/nonlinearRegression.html
+    public static Statistics CalculateParameterStatistics(double[,] jac, double[] coeff, double[] resid, double[] weight = null) {
+      var w = weight;
+      int numParam = coeff.Length;
+      int numRows = jac.GetLength(0);
+      if (jac.GetLength(1) != numParam) throw new ArgumentException("size of jac and coeff do not match"); // numParams includes offset
+      if (w == null) w = Enumerable.Repeat(1.0, numRows).ToArray();
+
+      var wresid = new double[numRows];
+      var wresid_norm2 = 0.0;
+      for (int i = 0; i < numRows; i++) {
+        wresid[i] = w[i] * resid[i];
+        wresid_norm2 += wresid[i] * wresid[i];
+      }
+
+      //  Calculate sample variance, the norm-squared of the residual
+      //     divided by the number of degrees of freedom.
+      var sigma2 = wresid_norm2 / (numRows - numParam);
+
+      // Compute sigma:
+      //               square-root of weighted residual norm squared divided
+      //               by number of degrees of freedom.
+      var sigma = Math.Sqrt(sigma2);
+
+      // Compute RMS = sigma^2:
+      //               the weighted residual norm divided by the number of
+      //               degrees of freedom.
+      //               RMS = wresid_norm / sqrt(m-n+q)
+      var RMS = sigma2;
+
+      /////////////////////////////////////////////////////////////////////////
+      //
+      // Compute some additional statistical diagnostics for the
+      // solution
+      //
+      /////////////////////////////////////////////////////////////////////////
+      // Calculate the covariance matrix CovMx, which is sigma ^ 2 times the
+      // inverse of H'*H, where
+      //              H = W * Jac
+      // contains the partial derivatives of wresid with
+      // respect to the parameters in coeff.
+      double[,] H = new double[numRows, numParam];
+      for (int i = 0; i < numRows; i++) {
+        for (int j = 0; j < numParam; j++)
+          H[i, j] = w[i] * jac[i, j];
+      }
+
+      // pseudo-inverse using QR
+      var qr = (double[,])H.Clone();
+      alglib.rmatrixqr(ref qr, numRows, numParam, out double[] tau);
+      alglib.rmatrixqrunpackq(qr, numRows, numParam, tau, numParam, out double[,] q);  // alglib does not have a way to left-apply Q using Householder representation. It should not matter here as numParam is usually small.
+      alglib.rmatrixqrunpackr(qr, numRows, numParam, out double[,] r);
+      // 
+      // 
+      // // identity
+      var T2 = new double[numParam, numParam];
+      for (int i = 0; i < numParam; i++) T2[i, i] = 1.0;
+
+      alglib.rmatrixlefttrsm(numParam, numParam, r, 0, 0, true, false, 0, ref T2, 0, 0);
+      var CovMx_QR = new double[numParam, numParam];
+      alglib.rmatrixgemm(numParam, numParam, numParam, sigma2, T2, 0, 0, 0, T2, 0, 0, 1, 0.0, ref CovMx_QR, 0, 0);
+
+      // pseudo inverse using truncated SVD
+      alglib.rmatrixsvd(H, numRows, numParam, uneeded: 1, vtneeded: 1, additionalmemory: 2, out var wDiag, out var u, out var vt);
+      var rank = 0;
+      var eps = 2.2204e-16;
+
+      while (rank < wDiag.Length && wDiag[rank] > numParam * eps * wDiag[0]) rank++;
+      // pseudo inverse H+ = V_r (D_r)^(-1) (U_r)^T
+      var DU = new double[rank, numRows]; // (D^)-1 (U_r)^T
+      for (int i = 0; i < rank; i++) {
+        for (int j = 0; j < numRows; j++) {
+          DU[i, j] = (1.0 / wDiag[i]) * u[j, i];
+        }
+      }
+      var H_pInv = new double[numParam, numRows];
+      alglib.rmatrixgemm(numParam, numRows, rank, 1.0, vt, 0, 0, 1, DU, 0, 0, 0, 0.0, ref H_pInv, 0, 0);
+
+      var CovMx = new double[numParam, numParam];
+      alglib.rmatrixgemm(numParam, numParam, numRows, sigma2, H_pInv, 0, 0, 0, H_pInv, 0, 0, 1, 0.0, ref CovMx, 0, 0);
+
+      // Compute Regression.CorMx:
+      //               estimated correlation matrix (numParam) x (numParam) for the
+      //               parameters. 
+      var CorMx = new double[numParam, numParam];
+      for (int i = 0; i < numParam; i++)
+        for (int j = 0; j < numParam; j++) {
+          CorMx[i, j] = 1.0 / Math.Sqrt(CovMx[i, i]) *
+                                   CovMx[i, j] *
+                                   1.0 / Math.Sqrt(CovMx[j, j]);
+        }
+
+      // Compute Regression.std_param:
+      //               The k-th element is the square root of the k-th main
+      //               diagonal element of CovMx.
+      var std_param = new double[numParam];
+      for (int i = 0; i < numParam; i++) std_param[i] = Math.Sqrt(CovMx[i, i]);
+
+      // Compute Regression.t_ratio:
+      //               parameter estimates divided by their standard deviations.
+      var t_ratio = new double[numParam];
+      Array.Copy(coeff, t_ratio, coeff.Length);
+      for (int i = 0; i < numParam; i++) t_ratio[i] /= std_param[i];
+
+      // compute p-value from t-ratio
+      var pValue = new double[numParam];
+      for (int i = 0; i < numParam; i++) {
+        if (t_ratio[i] == 0.0) pValue[i] = 1.0;
+        else pValue[i] = 2 * (1 - alglib.studenttdistr.studenttdistribution(numRows - numParam, Math.Abs(t_ratio[i]), null)); // degrees of freedom: https://en.wikipedia.org/wiki/T-statistic
+      }
+
+      // only for linear models?
+      // Compute Regression.standardized_wresid:
+      //               The k-th component is the k-th component of the
+      //               weighted residual, divided by its standard deviation.
+      //               Let X = W*[Phi],
+      //                   h(k) = k-th main diagonal element of covariance
+      //                          matrix for wresid
+      //                        = k-th main diagonal element of X*inv(X'*X)*X'
+      //                        = k-th main diagonal element of Qj*Qj'.
+      //               Then the standard deviation is estimated by
+      //               sigma*sqrt(1-h(k)).
+      // var temp = new double[numRows];
+      var standardized_wresid = new double[numRows];
+      // for (int k = 0; k < numRows; k++) {
+      //   for (int i = 0; i < numParam; i++) {
+      //     temp[k] += q[k, i] * q[k, i];
+      //   }
+      //   standardized_wresid[k] = wresid[k] / (sigma * Math.Sqrt(1 - temp[k]));
+      // }
+
+      return new Statistics() {
+        coeff = coeff,
+        sigma = sigma,
+        RMS = RMS,
+        CorMx = CorMx,
+        CovMx = CovMx,
+        std_param = std_param,
+        t_ratio = t_ratio,
+        p_value = pValue,
+        standardized_wresid = standardized_wresid
+      };
+    }
+  }
+}
Index: branches/3128_Prediction_Intervals/HeuristicLab.Common/3.3/MatrixExtensions.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Common/3.3/MatrixExtensions.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Common/3.3/MatrixExtensions.cs	(revision 17991)
@@ -96,4 +96,31 @@
       return result;
     }
+
+    /// <summary>
+    /// Concatenates matrices horizontally.
+    /// A      B
+    /// 1 2    9 8
+    /// 3 4    7 6
+    /// 
+    /// HorzCat(A, B)
+    /// 1 2 9 8
+    /// 3 4 7 6
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="a"></param>
+    /// <param name="b"></param>
+    /// <returns>A new matrix with the number of columns = a.GetLength(1) + b.GetLength(1)</returns>
+    public static T[,] HorzCat<T>(this T[,] a, T[] b) {
+      Contract.Assert(a.GetLength(0) == b.Length);
+      var aLen = a.GetLength(1);
+      var bLen = 1;
+      var result = new T[a.GetLength(0), aLen + bLen];
+      for (int i = 0; i < a.GetLength(0); i++)
+        for (int j = 0; j < aLen; j++)
+          result[i, j] = a[i, j];
+      for (int i = 0; i < a.GetLength(0); i++)
+        result[i, aLen] = b[i];
+      return result;
+    }
   }
 }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4.csproj
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4.csproj	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4.csproj	(revision 17991)
@@ -164,4 +164,8 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425B4-4348-49ED-A457-B7D2C26DDBF9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
       <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/Plugin.cs.frame
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/Plugin.cs.frame	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/Plugin.cs.frame	(revision 17991)
@@ -29,4 +29,5 @@
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views-3.4.dll",PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Algorithms.DataAnalysis", "3.4")]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
   [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs	(revision 17991)
@@ -24,5 +24,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("a411e2b5-f926-41a6-b55b-1aef862db2fb")]
-  public interface ISymbolicRegressionModel : IRegressionModel, ISymbolicDataAnalysisModel {
+  public interface ISymbolicRegressionModel : IRegressionModel, ISymbolicDataAnalysisModel, IConfidenceRegressionModel {
     void Scale(IRegressionProblemData problemData);
   }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs	(revision 17991)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("dff1a450-e958-454f-bf8e-6b763fdcaff3")]
-  public interface ISymbolicRegressionSolution : IRegressionSolution, ISymbolicDataAnalysisSolution {
+  public interface ISymbolicRegressionSolution : IRegressionSolution, ISymbolicDataAnalysisSolution, IConfidenceRegressionSolution {
     new ISymbolicRegressionModel Model { get; }
   }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingBestSolutionAnalyzer.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingBestSolutionAnalyzer.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveTrainingBestSolutionAnalyzer.cs	(revision 17991)
@@ -25,4 +25,9 @@
 using HeuristicLab.Parameters;
 using HEAL.Attic;
+using HeuristicLab.Data;
+using System.Collections.Generic;
+using System;
+using System.Linq;
+using HeuristicLab.Analysis.Statistics;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -63,7 +68,63 @@
 
     protected override ISymbolicRegressionSolution CreateSolution(ISymbolicExpressionTree bestTree, double bestQuality) {
-      var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable, (ISymbolicExpressionTree)bestTree.Clone(), SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper);
+
+      // HACK: create model first for scaling, then calculate statistics and create a new model with prediction intervals
+      var model = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
+        (ISymbolicExpressionTree)bestTree.Clone(),
+        SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
+        EstimationLimitsParameter.ActualValue.Lower,
+        EstimationLimitsParameter.ActualValue.Upper);
       if (ApplyLinearScalingParameter.ActualValue.Value) model.Scale(ProblemDataParameter.ActualValue);
-      return new SymbolicRegressionSolution(model, (IRegressionProblemData)ProblemDataParameter.ActualValue.Clone());
+
+      // use scaled tree
+      CalculateParameterCovariance(model.SymbolicExpressionTree, ProblemDataParameter.ActualValue, SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, out var cov, out var sigma);
+      var predIntervalModel = new SymbolicRegressionModel(ProblemDataParameter.ActualValue.TargetVariable,
+        (ISymbolicExpressionTree)model.SymbolicExpressionTree.Clone(),
+        SymbolicDataAnalysisTreeInterpreterParameter.ActualValue,
+        EstimationLimitsParameter.ActualValue.Lower,
+        EstimationLimitsParameter.ActualValue.Upper, parameterCovariance: cov, sigma: sigma);
+
+      return new SymbolicRegressionSolution(predIntervalModel, (IRegressionProblemData)ProblemDataParameter.ActualValue.Clone());
+    }
+
+    private void CalculateParameterCovariance(ISymbolicExpressionTree tree, IRegressionProblemData problemData, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, out double[,] cov, out double sigma) {
+      var y_pred = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.TrainingIndices).ToArray();
+      var residuals = problemData.TargetVariableTrainingValues.Zip(y_pred, (yi, y_pred_i) => yi - y_pred_i).ToArray();
+
+      var paramNodes = new List<ISymbolicExpressionTreeNode>();
+      var coeffList = new List<double>();
+      foreach (var node in tree.IterateNodesPostfix()) {
+        if (node is ConstantTreeNode constNode) {
+          paramNodes.Add(constNode);
+          coeffList.Add(constNode.Value);
+        } else if (node is VariableTreeNode varNode) {
+          paramNodes.Add(varNode);
+          coeffList.Add(varNode.Weight);
+        }
+      }
+      var coeff = coeffList.ToArray();
+      var numParams = coeff.Length;
+
+      var rows = problemData.TrainingIndices.ToArray();
+      var dcoeff = new double[rows.Length, numParams];
+      TreeToAutoDiffTermConverter.TryConvertToAutoDiff(tree, makeVariableWeightsVariable: true, addLinearScalingTerms: false,
+        out var parameters, out var initialConstants, out var func, out var func_grad);
+      if (initialConstants.Zip(coeff, (ici, coi) => ici != coi).Any(t => t)) throw new InvalidProgramException();
+      var ds = problemData.Dataset;
+      var x_r = new double[parameters.Count];
+      for (int r = 0; r < rows.Length; r++) {
+        // copy row
+        for (int c = 0; c < parameters.Count; c++) {
+          x_r[c] = ds.GetDoubleValue(parameters[c].variableName, rows[r]);
+        }
+        var tup = func_grad(coeff, x_r);
+        for (int c = 0; c < numParams; c++) {
+          dcoeff[r, c] = tup.Item1[c];
+        }
+      }
+
+      var stats = Statistics.CalculateLinearModelStatistics(dcoeff, coeff, residuals);
+      cov = stats.CovMx;
+      sigma = stats.sigma;
     }
   }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 17991)
@@ -26,4 +26,6 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HEAL.Attic;
+using HeuristicLab.Data;
+using System.Linq;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -45,4 +47,9 @@
     }
 
+    [Storable]
+    private readonly double[,] parameterCovariance;
+    [Storable]
+    private readonly double sigma;
+
     [StorableConstructor]
     protected SymbolicRegressionModel(StorableConstructorFlag _) : base(_) {
@@ -53,11 +60,16 @@
       : base(original, cloner) {
       this.targetVariable = original.targetVariable;
+      this.parameterCovariance = original.parameterCovariance; // immutable
+      this.sigma = original.sigma;
     }
 
     public SymbolicRegressionModel(string targetVariable, ISymbolicExpressionTree tree,
       ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue)
+      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue, double[,] parameterCovariance = null, double sigma = 0.0)
       : base(tree, interpreter, lowerEstimationLimit, upperEstimationLimit) {
       this.targetVariable = targetVariable;
+      if (parameterCovariance != null)
+        this.parameterCovariance = (double[,])parameterCovariance.Clone();
+      this.sigma = sigma;
     }
 
@@ -69,4 +81,64 @@
       return Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, rows)
         .LimitToRange(LowerEstimationLimit, UpperEstimationLimit);
+    }
+
+    public IEnumerable<double> GetEstimatedVariances(IDataset dataset, IEnumerable<int> rows) {
+      // must work with a copy because we change tree nodes
+      var treeCopy = (ISymbolicExpressionTree)SymbolicExpressionTree.Clone();
+      // uses sampling to produce prediction intervals
+      alglib.hqrndseed(31415, 926535, out var state);
+      var cov = parameterCovariance;
+      if (cov == null || cov.Length == 0) return rows.Select(_ => 0.0);
+      var n = 30;
+      var M = rows.Select(_ => new double[n]).ToArray();
+      var paramNodes = new List<ISymbolicExpressionTreeNode>();
+      var coeffList = new List<double>();
+      // HACK: skip linear scaling parameters because the analyzer doesn't use them (and they are likely correlated with the remaining parameters)
+      // only works with linear scaling
+      if (!(treeCopy.Root.GetSubtree(0).GetSubtree(0).Symbol is Addition) ||
+          !(treeCopy.Root.GetSubtree(0).GetSubtree(0).GetSubtree(0).Symbol is Multiplication)) 
+        throw new NotImplementedException("prediction intervals are implemented only for linear scaling");
+
+      foreach (var node in treeCopy.Root.GetSubtree(0).GetSubtree(0).IterateNodesPostfix()) {
+        if (node is ConstantTreeNode constNode) {
+          paramNodes.Add(constNode);
+          coeffList.Add(constNode.Value);
+        } else if (node is VariableTreeNode varNode) {
+          paramNodes.Add(varNode);
+          coeffList.Add(varNode.Weight);
+        }
+      }
+      var coeff = coeffList.ToArray();
+      var numParams = coeff.Length;
+      if (cov.GetLength(0) != numParams) throw new InvalidProgramException();
+
+      // TODO: probably we do not need to sample but can instead use a first-order or second-order approximation of f
+      // see http://sia.webpopix.org/nonlinearRegression.html
+      // also see https://rmazing.wordpress.com/2013/08/26/predictnls-part-2-taylor-approximation-confidence-intervals-for-nls-models/
+      // https://www.rdocumentation.org/packages/propagate/versions/1.0-4/topics/predictNLS
+      double[] p = new double[numParams];
+      for (int i = 0; i < 30; i++) {
+        // sample and update parameter vector delta is 
+        alglib.hqrndnormalv(state, numParams, out var delta);
+        alglib.rmatrixmv(numParams, numParams, cov, 0, 0, 0, delta, 0, ref p, 0);
+        for (int j = 0; j < numParams; j++) {
+          if (paramNodes[j] is ConstantTreeNode constNode) constNode.Value = coeff[j] + p[j];
+          else if (paramNodes[j] is VariableTreeNode varNode) varNode.Weight = coeff[j] + p[j];
+        }
+        var r = 0;
+        var estimatedValues = Interpreter.GetSymbolicExpressionTreeValues(treeCopy, dataset, rows).LimitToRange(LowerEstimationLimit, UpperEstimationLimit);
+
+        foreach (var pred in estimatedValues) {
+          M[r++][i] = pred;
+        }
+      }
+
+      // reset parameters
+      for (int j = 0; j < numParams; j++) {
+        if (paramNodes[j] is ConstantTreeNode constNode) constNode.Value = coeff[j];
+        else if (paramNodes[j] is VariableTreeNode varNode) varNode.Weight = coeff[j];
+      }
+      var sigma2 = sigma * sigma;
+      return M.Select(M_i => M_i.Variance() + sigma2).ToArray();
     }
 
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 17991)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Collections.Generic;
 using System.Linq;
 using HEAL.Attic;
@@ -112,5 +113,5 @@
     }
 
-
+    IConfidenceRegressionModel IConfidenceRegressionSolution.Model => Model;
 
     [StorableConstructor]
@@ -215,4 +216,15 @@
       return intervalEvaluation;
     }
+
+    public IEnumerable<double> EstimatedVariances => GetEstimatedVariances(ProblemData.AllIndices);
+
+    public IEnumerable<double> EstimatedTrainingVariances => GetEstimatedVariances(ProblemData.TestIndices);
+
+    public IEnumerable<double> EstimatedTestVariances => GetEstimatedVariances(ProblemData.TestIndices);
+
+
+    public IEnumerable<double> GetEstimatedVariances(IEnumerable<int> rows) {
+      return Model.GetEstimatedVariances(ProblemData.Dataset, rows);
+    }
   }
 }
Index: branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 17991)
@@ -74,5 +74,5 @@
       AddEvaluationViewTypes();
 
-      //recover selection
+      // recover selection
       if (selectedName != null) {
         foreach (ListViewItem item in itemsListView.Items) {
Index: branches/3128_Prediction_Intervals/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/RegressionVariableImpactCalculationTest.cs
===================================================================
--- branches/3128_Prediction_Intervals/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/RegressionVariableImpactCalculationTest.cs	(revision 17990)
+++ branches/3128_Prediction_Intervals/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/RegressionVariableImpactCalculationTest.cs	(revision 17991)
@@ -46,5 +46,5 @@
       double rmsError;
       double cvRmsError;
-      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError);
+      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError, out _);
       Dictionary<string, double> expectedImpacts = GetExpectedValuesForLRTower();
 
@@ -59,5 +59,5 @@
       double rmsError;
       double cvRmsError;
-      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError);
+      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError, out _);
       Dictionary<string, double> expectedImpacts = GetExpectedValuesForLRMiba();
 
@@ -114,5 +114,5 @@
       double rmsError;
       double cvRmsError;
-      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError);
+      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError, out _);
       solution.ProblemData = LoadDefaultMibaProblem();
       RegressionSolutionVariableImpactsCalculator.CalculateImpacts(solution);
@@ -130,5 +130,5 @@
       double rmsError;
       double cvRmsError;
-      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError);
+      var solution = LinearRegression.CreateSolution(problemData, out rmsError, out cvRmsError, out _);
 
       Stopwatch watch = new Stopwatch();
