Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionEvaluator.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionEvaluator.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionEvaluator.cs	(revision 17579)
@@ -1,4 +1,3 @@
-﻿using HEAL.Attic;
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -20,5 +19,5 @@
  */
 #endregion
-
+using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionModel.cs	(revision 17579)
@@ -1,4 +1,3 @@
-﻿using HEAL.Attic;
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -21,4 +20,6 @@
 #endregion
 
+using HEAL.Attic;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("a411e2b5-f926-41a6-b55b-1aef862db2fb")]
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSolution.cs	(revision 17579)
@@ -22,4 +22,5 @@
 
 
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   [StorableType("dff1a450-e958-454f-bf8e-6b763fdcaff3")]
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 17579)
@@ -1,3 +1,3 @@
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -21,4 +21,5 @@
 
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -26,5 +27,4 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
-using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
@@ -47,4 +47,6 @@
     private const string TestNaNEvaluationsResultName = "Test NaN Evaluations";
 
+    private const string ModelBoundsResultName = "Model Bounds";
+
     public new ISymbolicRegressionModel Model {
       get { return (ISymbolicRegressionModel)base.Model; }
@@ -95,4 +97,21 @@
       private set { ((IntValue)EstimationLimitsResultCollection[TestNaNEvaluationsResultName].Value).Value = value; }
     }
+
+    public IntervalCollection ModelBoundsCollection {
+      get {
+        if (!ContainsKey(ModelBoundsResultName)) return null;
+        return (IntervalCollection)this[ModelBoundsResultName].Value;
+      }
+      private set {
+        if (ContainsKey(ModelBoundsResultName)) {
+          this[ModelBoundsResultName].Value = value;
+        } else {
+          Add(new Result(ModelBoundsResultName, "Results concerning the derivation of symbolic regression solution", value));
+        }
+
+      }
+    }
+
+
 
     [StorableConstructor]
@@ -118,4 +137,8 @@
       estimationLimitResults.Add(new Result(TestNaNEvaluationsResultName, "", new IntValue()));
       Add(new Result(EstimationLimitsResultsResultName, "Results concerning the estimation limits of symbolic regression solution", estimationLimitResults));
+
+      if (IntervalInterpreter.IsCompatible(Model.SymbolicExpressionTree))
+        Add(new Result(ModelBoundsResultName, "Results concerning the derivation of symbolic regression solution", new IntervalCollection()));
+
       RecalculateResults();
     }
@@ -139,4 +162,11 @@
         CalculateResults();
       }
+
+      if (!ContainsKey(ModelBoundsResultName)) {
+        if (IntervalInterpreter.IsCompatible(Model.SymbolicExpressionTree)) {
+          Add(new Result(ModelBoundsResultName, "Results concerning the derivation of symbolic regression solution", new IntervalCollection()));
+          CalculateResults();
+        }
+      }
     }
 
@@ -159,4 +189,30 @@
       TrainingNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TrainingIndices).Count(double.IsNaN);
       TestNaNEvaluations = Model.Interpreter.GetSymbolicExpressionTreeValues(Model.SymbolicExpressionTree, ProblemData.Dataset, ProblemData.TestIndices).Count(double.IsNaN);
+
+      //Check if the tree contains unknown symbols for the interval calculation
+      if (IntervalInterpreter.IsCompatible(Model.SymbolicExpressionTree))
+        ModelBoundsCollection = CalculateModelIntervals(this);
+    }
+
+    private static IntervalCollection CalculateModelIntervals(ISymbolicRegressionSolution solution) {
+      var intervalEvaluation = new IntervalCollection();
+      var interpreter = new IntervalInterpreter();
+      var problemData = solution.ProblemData;
+      var model = solution.Model;
+      var variableRanges = problemData.VariableRanges.GetReadonlyDictionary();
+
+      intervalEvaluation.AddInterval($"Target {problemData.TargetVariable}", new Interval(variableRanges[problemData.TargetVariable].LowerBound, variableRanges[problemData.TargetVariable].UpperBound));
+      intervalEvaluation.AddInterval("Model", interpreter.GetSymbolicExpressionTreeInterval(model.SymbolicExpressionTree, variableRanges));
+
+      if (DerivativeCalculator.IsCompatible(model.SymbolicExpressionTree)) {
+        foreach (var inputVariable in model.VariablesUsedForPrediction.OrderBy(v => v, new NaturalStringComparer())) {
+          var derivedModel = DerivativeCalculator.Derive(model.SymbolicExpressionTree, inputVariable);
+          var derivedResultInterval = interpreter.GetSymbolicExpressionTreeInterval(derivedModel, variableRanges);
+
+          intervalEvaluation.AddInterval(" ∂f/∂" + inputVariable, new Interval(derivedResultInterval.LowerBound, derivedResultInterval.UpperBound));
+        }
+      }
+
+      return intervalEvaluation;
     }
   }
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 17579)
@@ -35,7 +35,8 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   public abstract partial class InteractiveSymbolicDataAnalysisSolutionSimplifierView : AsynchronousContentView {
-    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> foldedNodes;
-    private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> changedNodes;
-    private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
+    private readonly Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+    private readonly Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> changedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+    private readonly Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+    private readonly Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
 
     private readonly ISymbolicDataAnalysisSolutionImpactValuesCalculator impactCalculator;
@@ -49,7 +50,4 @@
     protected InteractiveSymbolicDataAnalysisSolutionSimplifierView(ISymbolicDataAnalysisSolutionImpactValuesCalculator impactCalculator) {
       InitializeComponent();
-      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
-      changedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
-      nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
       this.Caption = "Interactive Solution Simplifier";
       this.impactCalculator = impactCalculator;
@@ -173,5 +171,8 @@
     protected override void OnContentChanged() {
       base.OnContentChanged();
-      foldedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
+      foldedNodes.Clear();
+      changedNodes.Clear();
+      nodeIntervals.Clear();
+      nodeImpacts.Clear();
       UpdateView();
       viewHost.Content = this.Content;
@@ -205,6 +206,21 @@
           foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
         }
-
-        nodeImpacts = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item1);
+        
+        foreach (var pair in impactAndReplacementValues) {
+          nodeImpacts[pair.Key] = pair.Value.Item1;
+        }
+
+        if (IntervalInterpreter.IsCompatible(tree)) { 
+          var regressionProblemData = Content.ProblemData as IRegressionProblemData;
+          if (regressionProblemData != null) {
+            var interpreter = new IntervalInterpreter();
+            var variableRanges = regressionProblemData.VariableRanges.GetReadonlyDictionary();
+            IDictionary<ISymbolicExpressionTreeNode, Interval> intervals;
+            interpreter.GetSymbolicExpressionTreeIntervals(tree, variableRanges, out intervals);
+            foreach (var kvp in intervals) {
+              nodeIntervals[kvp.Key] = kvp.Value;
+            }
+          }
+        }
       } finally {
         progress.Finish();
@@ -303,5 +319,7 @@
           }
         }
-        if (visualTree != null)
+        if (visualTree != null) {
+          if (nodeIntervals.ContainsKey(treeNode))
+            visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{nodeIntervals[treeNode].LowerBound:G5} ... {nodeIntervals[treeNode].UpperBound:G5}]");
           if (changedNodes.ContainsKey(treeNode)) {
             visualTree.LineColor = Color.DodgerBlue;
@@ -309,4 +327,5 @@
             visualTree.LineColor = Color.DarkOrange;
           }
+        }
       }
       treeChart.RepaintNodes();
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 17579)
@@ -23,9 +23,9 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HEAL.Attic;
 using HeuristicLab.Parameters;
 
@@ -80,5 +80,5 @@
     }
 
-    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -97,5 +97,5 @@
 
     public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
-      IDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+      IReadOnlyDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -124,5 +124,5 @@
 
 
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
+    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
@@ -234,12 +234,4 @@
             break;
           }
-        case OpCodes.Power: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-              result = Interval.Power(result, argumentInterval);
-            }
-            break;
-          }
         case OpCodes.Square: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
@@ -247,15 +239,31 @@
             break;
           }
-        case OpCodes.Root: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-              result = Interval.Root(result, argumentInterval);
-            }
-            break;
-          }
         case OpCodes.SquareRoot: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.SquareRoot(argumentInterval);
+            break;
+          }
+        case OpCodes.Cube: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.Cube(argumentInterval);
+            break;
+          }
+        case OpCodes.CubeRoot: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.CubicRoot(argumentInterval);
+            break;
+          }
+        case OpCodes.Absolute: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.Absolute(argumentInterval);
+            break;
+          }
+        case OpCodes.AnalyticQuotient: {
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+              result = Interval.AnalyticalQuotient(result, argumentInterval);
+            }
+
             break;
           }
@@ -274,4 +282,6 @@
         from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
         where
+          !(n.Symbol is Problems.DataAnalysis.Symbolic.Variable) &&
+          !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
           !(n.Symbol is Addition) &&
@@ -284,10 +294,10 @@
           !(n.Symbol is Logarithm) &&
           !(n.Symbol is Exponential) &&
-          !(n.Symbol is Power) &&
           !(n.Symbol is Square) &&
-          !(n.Symbol is Root) &&
           !(n.Symbol is SquareRoot) &&
-          !(n.Symbol is Problems.DataAnalysis.Symbolic.Variable) &&
-          !(n.Symbol is Constant)
+          !(n.Symbol is Cube) &&
+          !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Absolute) &&
+          !(n.Symbol is AnalyticQuotient)
         select n).Any();
       return !containsUnknownSyumbol;
Index: trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/PartialDependencePlot.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/PartialDependencePlot.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Controls/PartialDependencePlot.cs	(revision 17579)
@@ -36,5 +36,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Views {
   public partial class PartialDependencePlot : UserControl, IPartialDependencePlot {
-    private ModifiableDataset sharedFixedVariables; // used for syncronising variable values between charts
+    private ModifiableDataset sharedFixedVariables; // used for synchronizing variable values between charts
     private ModifiableDataset internalDataset; // holds the x values for each point drawn
 
@@ -351,6 +351,7 @@
 
     private void RecalculateTrainingLimits(bool initializeAxisRanges) {
-      trainingMin = solutions.Select(s => s.ProblemData.Dataset.GetDoubleValues(freeVariable, s.ProblemData.TrainingIndices).Where(x => !double.IsNaN(x)).Min()).Max();
-      trainingMax = solutions.Select(s => s.ProblemData.Dataset.GetDoubleValues(freeVariable, s.ProblemData.TrainingIndices).Where(x => !double.IsNaN(x)).Max()).Min();
+      //Set min and max to the interval ranges
+      trainingMin = solutions.Select(s => s.ProblemData.VariableRanges.GetInterval(freeVariable).LowerBound).Max();
+      trainingMax = solutions.Select(s => s.ProblemData.VariableRanges.GetInterval(freeVariable).UpperBound).Min();
 
       if (initializeAxisRanges) {
@@ -438,5 +439,5 @@
       chart.Palette = ChartColorPalette.None;
 
-      // Add confidence interval series before its coresponding series for correct z index
+      // Add confidence interval series before its corresponding series for correct z index
       foreach (var solution in solutions) {
         Series ciSeries;
Index: trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj	(revision 17579)
@@ -221,4 +221,10 @@
     <Compile Include="Interfaces\IDataPreprocessorStarter.cs" />
     <Compile Include="Interfaces\IPartialDependencePlot.cs" />
+    <Compile Include="IntervalCollectionView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="IntervalCollectionView.Designer.cs">
+      <DependentUpon>IntervalCollectionView.cs</DependentUpon>
+    </Compile>
     <Compile Include="MenuItems\ChangeDataOfOptimizersMenuItem.cs" />
     <Compile Include="MenuItems\ShrinkDataAnalysisRunsMenuItem.cs" />
Index: trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.Designer.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.Designer.cs	(revision 17579)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.Designer.cs	(revision 17579)
@@ -0,0 +1,82 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Problems.DataAnalysis.Views {
+  partial class IntervalCollectionView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.dataGridView = new System.Windows.Forms.DataGridView();
+      ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).BeginInit();
+      this.SuspendLayout();
+      // 
+      // dataGridView
+      // 
+      this.dataGridView.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize;
+      this.dataGridView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.dataGridView.Location = new System.Drawing.Point(0, 0);
+      this.dataGridView.Margin = new System.Windows.Forms.Padding(4);
+      this.dataGridView.Name = "dataGridView";
+      this.dataGridView.RowHeadersWidth = 120;
+      this.dataGridView.Size = new System.Drawing.Size(643, 505);
+      this.dataGridView.TabIndex = 1;
+      this.dataGridView.CellEndEdit += new System.Windows.Forms.DataGridViewCellEventHandler(this.dataGridView_CellEndEdit);
+      this.dataGridView.CellValidating += new System.Windows.Forms.DataGridViewCellValidatingEventHandler(this.dataGridView_CellValidating);
+      this.dataGridView.CellValueChanged += new System.Windows.Forms.DataGridViewCellEventHandler(this.dataGridView_CellValueChanged);
+      // 
+      // IntervalCollectionView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.dataGridView);
+      this.Margin = new System.Windows.Forms.Padding(4);
+      this.Name = "IntervalCollectionView";
+      this.Size = new System.Drawing.Size(643, 505);
+      ((System.ComponentModel.ISupportInitialize)(this.dataGridView)).EndInit();
+      this.ResumeLayout(false);
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.DataGridView dataGridView;
+  }
+}
Index: trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.cs	(revision 17579)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.cs	(revision 17579)
@@ -0,0 +1,153 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+
+using System.Windows.Forms;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.DataAnalysis.Views {
+
+  [View("IntervalCollection View")]
+  [Content(typeof(IntervalCollection), true)]
+  public sealed partial class IntervalCollectionView : AsynchronousContentView {
+
+    public new IntervalCollection Content {
+      get => (IntervalCollection)base.Content;
+      set => base.Content = value;
+    }
+
+    private DataGridView DataGridView {
+      get => dataGridView;
+    }
+
+    public IntervalCollectionView() {
+      InitializeComponent();
+      dataGridView.AutoGenerateColumns = false;
+      dataGridView.AllowUserToAddRows = false;
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content == null) {
+        DataGridView.Rows.Clear();
+        DataGridView.Columns.Clear();
+      } else {
+        UpdateData();
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      dataGridView.Enabled = Content != null;
+      dataGridView.ReadOnly = ReadOnly;
+    }
+
+    private void UpdateData() {
+      DataGridView.Rows.Clear();
+      DataGridView.Columns.Clear();
+      SetColumnNames();
+
+
+      var variablesCount = Content.Count;
+
+      DataGridViewRow[] rows = new DataGridViewRow[variablesCount];
+      for (var i = 0; i < variablesCount; ++i) {
+        var row = new DataGridViewRow();
+        rows[i] = row;
+      }
+      dataGridView.Rows.AddRange(rows);
+
+      var j = 0;
+      foreach (var variableInterval in Content.GetVariableIntervals()) {
+        dataGridView.Rows[j].HeaderCell.Value = variableInterval.Item1;
+        dataGridView.Rows[j].Cells[0].Value = variableInterval.Item2.LowerBound;
+        dataGridView.Rows[j].Cells[1].Value = variableInterval.Item2.UpperBound;
+        j++;
+      }
+
+      dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
+      dataGridView.AutoResizeRowHeadersWidth(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders);
+      dataGridView.Enabled = true;
+      //Disable Sorting
+      foreach (DataGridViewColumn column in dataGridView.Columns) {
+        column.SortMode = DataGridViewColumnSortMode.NotSortable;
+      }
+    }
+
+    private void SetColumnNames() {
+      dataGridView.Columns.Add("lowerBound", "Lower Bound");
+      dataGridView.Columns.Add("upperBound", "Upper Bound");
+    }
+
+    private void dataGridView_CellValueChanged(object sender, DataGridViewCellEventArgs e) {
+      if (e.ColumnIndex < 0 || e.RowIndex < 0) return;
+
+      var key = dataGridView.Rows[e.RowIndex].HeaderCell.Value.ToString();
+      var gridData = dataGridView[e.ColumnIndex, e.RowIndex].Value;
+      //Cells maybe null during initialization
+      var lowerBound = Content.GetInterval(key).LowerBound;
+      var upperBound = Content.GetInterval(key).UpperBound;
+
+      //Check if the input data is a string (user-defined input)
+      //if so parse the toString() of the value, otherwise do a hard-cast
+      //to not loose the double precision
+      double parsedValue;
+      if (gridData is string) {
+        parsedValue = double.Parse(gridData.ToString());
+      } else {
+        parsedValue = (double)gridData;
+      }
+
+      if (e.ColumnIndex == 0) lowerBound = parsedValue;
+      if (e.ColumnIndex == 1) upperBound = parsedValue;
+
+      var newInterval = new Interval(lowerBound, upperBound);
+
+      // update if there was a change
+      if (!Content.GetInterval(key).Equals(newInterval))
+        Content.SetInterval(key, newInterval);
+    }
+
+    private void dataGridView_CellValidating(object sender, DataGridViewCellValidatingEventArgs e) {
+      if (!double.TryParse(e.FormattedValue.ToString(), out var value)) {
+        e.Cancel = true;
+        dataGridView.Rows[e.RowIndex].ErrorText = "Value must be a double value.";
+        return;
+      }
+
+      var lowerBound = double.Parse(dataGridView.Rows[e.RowIndex].Cells[0].Value.ToString());
+      var upperBound = double.Parse(dataGridView.Rows[e.RowIndex].Cells[1].Value.ToString());
+
+      if (e.ColumnIndex == 0 && value > upperBound || e.ColumnIndex == 1 && value < lowerBound) {
+        e.Cancel = true;
+        dataGridView.Rows[e.RowIndex].ErrorText = "Lower bound of interval must be smaller than upper bound.";
+        return;
+      }
+
+      dataGridView[e.ColumnIndex, e.RowIndex].Value = value;
+    }
+
+    private void dataGridView_CellEndEdit(object sender, DataGridViewCellEventArgs e) {
+      dataGridView.Rows[e.RowIndex].ErrorText = string.Empty;
+    }
+  }
+}
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 17579)
@@ -140,5 +140,6 @@
     <Compile Include="Implementation\ConstantModel.cs" />
     <Compile Include="Implementation\DataAnalysisModel.cs" />
-    <Compile Include="Implementation\Interval.cs" />
+    <Compile Include="Implementation\Interval\Interval.cs" />
+    <Compile Include="Implementation\Interval\IntervalCollection.cs" />
     <Compile Include="Implementation\Regression\ConfidenceBoundRegressionSolution.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionModel.cs" />
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs	(revision 17579)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs	(revision 17579)
@@ -0,0 +1,279 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("849e42d3-8934-419d-9aff-64ad81c06b67")]
+  public class Interval : IEquatable<Interval> {
+    [Storable]
+    public double LowerBound { get; private set; }
+    [Storable]
+    public double UpperBound { get; private set; }
+
+    [StorableConstructor]
+    protected Interval(StorableConstructorFlag _) { }
+
+    /// <summary>
+    /// Creates an interval with given bounds, where lower bound must be smaller than
+    /// the upper bound. Floating point precision errors trough calculations are fixed by,
+    /// checking if the intervals are almost the same (E-12). If this is the case, the bounds 
+    /// will be set to the bound closer to zero.
+    /// </summary>
+    /// <param name="lowerBound">Lower bound of the interval</param>
+    /// <param name="upperBound">Upper bound of the interval</param>
+    public Interval(double lowerBound, double upperBound) {
+      if (lowerBound.IsAlmost(upperBound)) {
+        //If the bounds go over zero
+        if (lowerBound <= 0 && upperBound >= 0) {
+          lowerBound = 0.0;
+          upperBound = 0.0;
+          //Interval is negative
+        } else if (upperBound < 0) {
+          lowerBound = upperBound;
+          //Interval is positive
+        } else {
+          upperBound = lowerBound;
+        }
+      }
+
+      if (lowerBound > upperBound)
+        throw new ArgumentException("lowerBound must be smaller than or equal to upperBound.");
+
+      this.LowerBound = lowerBound;
+      this.UpperBound = upperBound;
+    }
+
+    public bool Contains(double value) {
+      return LowerBound <= value && value <= UpperBound;
+    }
+
+    public bool Contains(Interval other) {
+      if (double.IsNegativeInfinity(LowerBound) && double.IsPositiveInfinity(UpperBound)) return true;
+      if (other.LowerBound >= LowerBound && other.UpperBound <= UpperBound) return true;
+  
+      return false;
+    }
+
+    public override string ToString() {
+      return "Interval: [" + LowerBound + ", " + UpperBound + "]";
+    }
+
+    public bool IsInfiniteOrUndefined {
+      get {
+        return double.IsInfinity(LowerBound) || double.IsInfinity(UpperBound) ||
+                double.IsNaN(LowerBound) || double.IsNaN(UpperBound);
+      }
+    }
+
+    /// <summary>
+    /// True if the interval is positive without zero
+    /// </summary>
+    public bool IsPositive {
+      get => LowerBound > 0.0; 
+    }
+
+    /// <summary>
+    /// True if the interval is negative without zero
+    /// </summary>
+    public bool IsNegative {
+      get => UpperBound < 0.0;
+    }
+
+    public static Interval GetInterval(IEnumerable<double> values) {
+      if (values == null) throw new ArgumentNullException("values");
+      if (!values.Any()) throw new ArgumentException($"No values are present.");
+
+      var min = double.MaxValue;
+      var max = double.MinValue;
+
+      foreach (var value in values) {
+        //If an value is NaN return an interval [NaN, NaN]
+        if (double.IsNaN(value)) return new Interval(double.NaN, double.NaN);
+
+        if (value < min) min = value;
+        if (value > max) max = value;
+      }
+
+      return new Interval(min, max);
+    }
+
+    #region Equals, GetHashCode, == , !=
+    public bool Equals(Interval other) {
+      if (other == null)
+        return false;
+
+      return (UpperBound.IsAlmost(other.UpperBound) || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
+        && (LowerBound.IsAlmost(other.LowerBound) || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
+    }
+
+    public override bool Equals(object obj) {
+      return Equals(obj as Interval);
+    }
+
+    public override int GetHashCode() {
+      return LowerBound.GetHashCode() ^ UpperBound.GetHashCode();
+    }
+
+    public static bool operator ==(Interval interval1, Interval interval2) {
+      if (ReferenceEquals(interval1, null)) return ReferenceEquals(interval2, null);
+      return interval1.Equals(interval2);
+    }
+    public static bool operator !=(Interval interval1, Interval interval2) {
+      return !(interval1 == interval2);
+    }
+    #endregion
+
+    #region operations
+
+    // [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
+    public static Interval Add(Interval a, Interval b) {
+      return new Interval(a.LowerBound + b.LowerBound, a.UpperBound + b.UpperBound);
+    }
+
+    // [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
+    public static Interval Subtract(Interval a, Interval b) {
+      return new Interval(a.LowerBound - b.UpperBound, a.UpperBound - b.LowerBound);
+    }
+
+    // [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
+    public static Interval Multiply(Interval a, Interval b) {
+      double v1 = a.LowerBound * b.LowerBound;
+      double v2 = a.LowerBound * b.UpperBound;
+      double v3 = a.UpperBound * b.LowerBound;
+      double v4 = a.UpperBound * b.UpperBound;
+
+      double min = Math.Min(Math.Min(v1, v2), Math.Min(v3, v4));
+      double max = Math.Max(Math.Max(v1, v2), Math.Max(v3, v4));
+      return new Interval(min, max);
+    }
+
+    //Division by intervals containing 0 is implemented as defined in
+    //http://en.wikipedia.org/wiki/Interval_arithmetic
+    public static Interval Divide(Interval a, Interval b) {
+      if (b.Contains(0.0)) {
+        if (b.LowerBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, double.PositiveInfinity));
+        else if (b.UpperBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(double.NegativeInfinity, 1.0 / b.LowerBound));
+        else return new Interval(double.NegativeInfinity, double.PositiveInfinity);
+      }
+      return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, 1.0 / b.LowerBound));
+    }
+
+    public static Interval Sine(Interval a) {
+      if (Math.Abs(a.UpperBound - a.LowerBound) >= Math.PI * 2) return new Interval(-1, 1);
+
+      //divide the interval by PI/2 so that the optima lie at x element of N (0,1,2,3,4,...)
+      double Pihalf = Math.PI / 2;
+      Interval scaled = Interval.Divide(a, new Interval(Pihalf, Pihalf));
+      //move to positive scale
+      if (scaled.LowerBound < 0) {
+        int periodsToMove = Math.Abs((int)scaled.LowerBound / 4) + 1;
+        scaled = Interval.Add(scaled, new Interval(periodsToMove * 4, periodsToMove * 4));
+      }
+
+      double scaledLowerBound = scaled.LowerBound % 4.0;
+      double scaledUpperBound = scaled.UpperBound % 4.0;
+      if (scaledUpperBound < scaledLowerBound) scaledUpperBound += 4.0;
+      List<double> sinValues = new List<double>();
+      sinValues.Add(Math.Sin(scaledLowerBound * Pihalf));
+      sinValues.Add(Math.Sin(scaledUpperBound * Pihalf));
+
+      int startValue = (int)Math.Ceiling(scaledLowerBound);
+      while (startValue < scaledUpperBound) {
+        sinValues.Add(Math.Sin(startValue * Pihalf));
+        startValue += 1;
+      }
+
+      return new Interval(sinValues.Min(), sinValues.Max());
+    }
+    public static Interval Cosine(Interval a) {
+      return Interval.Sine(Interval.Add(a, new Interval(Math.PI / 2, Math.PI / 2)));
+    }
+    public static Interval Tangens(Interval a) {
+      return Interval.Divide(Interval.Sine(a), Interval.Cosine(a));
+    }
+    public static Interval HyperbolicTangent(Interval a) {
+      return new Interval(Math.Tanh(a.LowerBound), Math.Tanh(a.UpperBound));
+    }
+
+    public static Interval Logarithm(Interval a) {
+      return new Interval(Math.Log(a.LowerBound), Math.Log(a.UpperBound));
+    }
+    public static Interval Exponential(Interval a) {
+      return new Interval(Math.Exp(a.LowerBound), Math.Exp(a.UpperBound));
+    }
+
+    public static Interval Square(Interval a) {
+      if (a.UpperBound <= 0) return new Interval(a.UpperBound * a.UpperBound, a.LowerBound * a.LowerBound);     // interval is negative
+      else if (a.LowerBound >= 0) return new Interval(a.LowerBound * a.LowerBound, a.UpperBound * a.UpperBound); // interval is positive
+      else return new Interval(0, Math.Max(a.LowerBound * a.LowerBound, a.UpperBound * a.UpperBound)); // interval goes over zero
+    }
+
+    public static Interval Cube(Interval a) {
+      return new Interval(Math.Pow(a.LowerBound, 3), Math.Pow(a.UpperBound, 3));
+    }
+
+    /// <summary>
+    /// Calculates the principal square root of a given interval. Discards the second possible result of root, because
+    /// all interpreters just calculate the positive principal root.
+    /// </summary>
+    /// <param name="a">Interval to build square root from.</param>
+    /// <returns></returns>
+    public static Interval SquareRoot(Interval a) {
+      if (a.LowerBound < 0) return new Interval(double.NaN, double.NaN);
+      return new Interval(Math.Sqrt(a.LowerBound), Math.Sqrt(a.UpperBound));
+    }
+
+    public static Interval CubicRoot(Interval a) {
+      var lower = (a.LowerBound < 0) ? -Math.Pow(-a.LowerBound, 1d / 3d) : Math.Pow(a.LowerBound, 1d / 3d);
+      var upper = (a.UpperBound < 0) ? -Math.Pow(-a.UpperBound, 1d / 3d) : Math.Pow(a.UpperBound, 1d / 3d);
+
+      return new Interval(lower, upper);
+    }
+
+    public static Interval Absolute(Interval a) {
+      var absLower = Math.Abs(a.LowerBound);
+      var absUpper = Math.Abs(a.UpperBound);
+      var min = Math.Min(absLower, absUpper);
+      var max = Math.Max(absLower, absUpper);
+
+      if (a.Contains(0.0)) {
+        min = 0.0;
+      }
+
+      return new Interval(min, max);
+    }
+
+    public static Interval AnalyticalQuotient(Interval a, Interval b) {
+      var dividend = a;
+      var divisor = Add(Square(b), new Interval(1.0, 1.0));
+      divisor = SquareRoot(divisor);
+
+      var quotient = Divide(dividend, divisor);
+      return quotient;
+    }
+    #endregion
+  }
+}
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs	(revision 17579)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs	(revision 17579)
@@ -0,0 +1,102 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [Item("IntervalCollection", "Represents variables with their interval ranges.")]
+  [StorableType("230B4E4B-41E5-4D33-9BC3-E2DAADDCA5AE")]
+  public class IntervalCollection : Item {
+    public static new System.Drawing.Image StaticItemImage {
+      get => HeuristicLab.Common.Resources.VSImageLibrary.Object;
+    }
+    private IDictionary<string, Interval> intervals { get; } = new Dictionary<string, Interval>();
+
+    [Storable(Name = "StorableIntervalInformation")]
+    private KeyValuePair<string, double[]>[] StorableIntervalInformation {
+      get {
+        var l = new List<KeyValuePair<string, double[]>>();
+        foreach (var varInt in intervals)
+
+          l.Add(new KeyValuePair<string, double[]>(varInt.Key,
+            new double[] { varInt.Value.LowerBound, varInt.Value.UpperBound }));
+        return l.ToArray();
+      }
+
+      set {
+        foreach (var varInt in value)
+          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
+      }
+    }
+
+    public int Count => intervals.Count;
+
+    public IntervalCollection() : base() { }
+    [StorableConstructor]
+    protected IntervalCollection(StorableConstructorFlag _) : base(_) { }
+
+    protected IntervalCollection(IntervalCollection original, Cloner cloner) : base(original, cloner) {
+      foreach (var keyValuePair in original.intervals) {
+        intervals.Add(keyValuePair.Key, new Interval(keyValuePair.Value.LowerBound, keyValuePair.Value.UpperBound));
+      }
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntervalCollection(this, cloner);
+    }
+
+    public IntervalCollection(IDictionary<string, Interval> intervals) {
+      this.intervals = intervals;
+    }
+
+    public Interval GetInterval(string identifier) {
+      if (!intervals.ContainsKey(identifier)) throw new ArgumentException($"The given identifier:{ identifier } is not present!");
+
+      return intervals[identifier];
+    }
+
+    public void SetInterval(string identifier, Interval interval) {
+      intervals[identifier] = interval;
+    }
+
+    public void AddInterval(string identifier, Interval interval) {
+      intervals.Add(identifier, interval);
+    }
+
+    public void DeleteInterval(string identifier) {
+      intervals.Remove(identifier);
+    }
+
+    public IReadOnlyDictionary<string, Interval> GetReadonlyDictionary() {
+      return intervals.ToDictionary(pair => pair.Key, pair => pair.Value);
+    }
+
+    public IEnumerable<Tuple<string, Interval>> GetVariableIntervals() {
+      foreach (var variableInterval in intervals)
+        yield return Tuple.Create(variableInterval.Key, variableInterval.Value);
+    }
+  }
+}
+
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 17579)
@@ -1,3 +1,3 @@
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -23,9 +23,9 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -34,4 +34,6 @@
   public class RegressionProblemData : DataAnalysisProblemData, IRegressionProblemData, IStorableContent {
     protected const string TargetVariableParameterName = "TargetVariable";
+    protected const string VariableRangesParameterName = "VariableRanges";
+    protected const string IntervalConstraintsParameterName = "IntervalConstraints";
     public string Filename { get; set; }
 
@@ -91,4 +93,5 @@
       problemData.Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", (IntRange)new IntRange(0, 0).AsReadOnly()));
       problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
+      problemData.Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, "", new IntervalCollection()));
       emptyProblemData = problemData;
     }
@@ -98,4 +101,12 @@
       get { return (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     }
+
+    public IFixedValueParameter<IntervalCollection> VariableRangesParameter => (IFixedValueParameter<IntervalCollection>)Parameters[VariableRangesParameterName];
+
+    public IntervalCollection VariableRanges {
+      get => VariableRangesParameter.Value;
+    }
+
+
     public string TargetVariable {
       get { return TargetVariableParameter.Value.Value; }
@@ -125,4 +136,8 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(VariableRangesParameterName)) {
+        var intervalCollection = CalculateDatasetIntervals(this.Dataset);
+        Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
+      }
       RegisterParameterEvents();
     }
@@ -152,5 +167,17 @@
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
+      var intervalCollection = CalculateDatasetIntervals(this.Dataset);
+      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
       RegisterParameterEvents();
+    }
+
+    private static IntervalCollection CalculateDatasetIntervals(IDataset dataset) {
+      IntervalCollection intervalCollection = new IntervalCollection();
+      foreach (var variable in dataset.DoubleVariables) {// intervals are only possible for double variables
+        var variableInterval = Interval.GetInterval(dataset.GetDoubleValues(variable));
+        intervalCollection.AddInterval(variable, variableInterval);
+      }
+
+      return intervalCollection;
     }
 
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisModel.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisModel.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisModel.cs	(revision 17579)
@@ -25,9 +25,9 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  [StorableType("f85ccf7a-7df5-431e-bc4d-be6f3c4c2338")]
   /// <summary>
   /// Interface for all data-analysis models (regression/classification/clustering).
   /// <remarks>All methods and properties in in this interface must be implemented thread safely</remarks>
   /// </summary>
+  [StorableType("f85ccf7a-7df5-431e-bc4d-be6f3c4c2338")]
   public interface IDataAnalysisModel : INamedItem {
     IEnumerable<string> VariablesUsedForPrediction { get; }
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblem.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblem.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblem.cs	(revision 17579)
@@ -35,5 +35,5 @@
   [StorableType("c2f6fcdd-ab62-4423-be75-01aa694df411")]
   public interface IDataAnalysisProblem<T> : IDataAnalysisProblem
-  where T : class, IDataAnalysisProblemData {
+    where T : class, IDataAnalysisProblemData {
     new IValueParameter<T> ProblemDataParameter { get; }
     new T ProblemData { get; set; }
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDependencyCalculator.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDependencyCalculator.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDependencyCalculator.cs	(revision 17579)
@@ -22,6 +22,8 @@
 using System;
 using System.Collections.Generic;
+using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("3283B3FB-8467-4B99-9B6E-23BF3D1B8505")]
   public interface IDependencyCalculator {
     double Maximum { get; }
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs	(revision 17579)
@@ -22,6 +22,9 @@
 
 using System;
+using HEAL.Attic;
+
 namespace HeuristicLab.Problems.DataAnalysis {
   [Flags]
+  [StorableType("8A28DDA1-4814-4B77-9457-0EE930BE9C73")]
   public enum OnlineCalculatorError {
     /// <summary>
@@ -38,4 +41,6 @@
     InsufficientElementsAdded = 2
   }
+
+  [StorableType("119C8242-3EE7-4C34-A7AC-68ABF76EB11B")]
   public interface IOnlineCalculator {
     OnlineCalculatorError ErrorState { get; }
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 17579)
@@ -28,4 +28,6 @@
     string TargetVariable { get; set; }
 
+    IntervalCollection VariableRanges { get;}
+
     IEnumerable<double> TargetVariableValues { get; }
     IEnumerable<double> TargetVariableTrainingValues { get; }
Index: trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/IOnlineTimeSeriesCalculator.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/IOnlineTimeSeriesCalculator.cs	(revision 17576)
+++ trunk/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/IOnlineTimeSeriesCalculator.cs	(revision 17579)
@@ -22,6 +22,8 @@
 
 using System.Collections.Generic;
+using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("7461AC5D-9D9A-4DCD-B32F-602260E58FFC")]
   public interface IOnlineTimeSeriesCalculator {
     OnlineCalculatorError ErrorState { get; }
