Index: /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs
===================================================================
--- /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs	(revision 16312)
+++ /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs	(revision 16313)
@@ -42,5 +42,6 @@
     private readonly object syncRoot = new object();
 
-    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
+    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, 
+      IEnumerable<int> rows, IDataset dataset = null, Dictionary<string, Interval> customIntervals = null) {
       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
       int necessaryArgStackSize = 0;
@@ -51,11 +52,24 @@
           IList<double> values = new List<double>();
 
-          if (customIntervals != null && customIntervals.ContainsKey(variableTreeNode.VariableName)) {
-            instr.data = customIntervals[variableTreeNode.VariableName];
+          if (dataset != null && customIntervals != null) {
+            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) {
+              instr.data = customIntervals[variableTreeNode.VariableName];
+            } else {
+              foreach (var rowEnum in rows) {
+                values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+              }
+              instr.data = new Interval(values.Min(), values.Max());
+            }
+          } else if (dataset != null) {
+             foreach (var rowEnum in rows) {
+              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+            }
+            instr.data = new Interval(values.Min(), values.Max());
+          } else if (customIntervals != null) {
+            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) { 
+              instr.data = customIntervals[variableTreeNode.VariableName];
+            }
           } else {
-            foreach (var rowEnum in rows) {
-              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
-            }
-            instr.data = new Interval(values.Min(), values.Max());
+            throw new Exception("No valid input for variables!");
           }
         }
@@ -204,14 +218,32 @@
     //  var x = Evaluate(dataset, state);
     //  state.Reset();
-      
+
     //  return state;
     //}
 
-   // public Interval GetSymbolicExressionTreeInterval(tree,variableIntervals)
+    // public Interval GetSymbolicExressionTreeInterval(tree,variableIntervals)
     //public Interval GetSymbolicExressionTreeInterval(tree,Dataset,intervals = null)
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IEnumerable<int> rows, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+      var state = PrepareInterpreterState(tree, rows);
+      var x = Evaluate(state, intervals);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows,
+      Dictionary<string, Interval> customIntervals, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+      var state = PrepareInterpreterState(tree, rows, dataset, customIntervals);
+      var x = Evaluate(state, intervals);
+
+      return x;
+    }
+
     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 
       out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var state = PrepareInterpreterState(tree, dataset, rows);
+      var state = PrepareInterpreterState(tree, rows, dataset);
       var x = Evaluate(state, intervals);
       
Index: /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs
===================================================================
--- /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs	(revision 16312)
+++ /branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs	(revision 16313)
@@ -29,5 +29,5 @@
 namespace HeuristicLab.Algorithms.DataAnalysis.IntervalArithmetic
 {
-    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.0")]
+    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.16303")]
     [PluginFile("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.dll", PluginFileType.Assembly)]
     public class Plugin : PluginBase{
Index: /branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- /branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 16312)
+++ /branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 16313)
@@ -34,4 +34,5 @@
 using HeuristicLab.MainForm;
 using HeuristicLab.MainForm.WindowsForms;
+using System.Globalization;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
@@ -193,12 +194,14 @@
       var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
 
-      //var intervalParam = ((IRegressionProblemData)Content.ProblemData).IntervalVariable;
+      //Get the Variable Ranges and add it to the dictionary 
+      var intervalParameters = ((IRegressionProblemData)Content.ProblemData).VariableRanges;
       var customIntervals = new Dictionary<String, Interval>();
-      var parser = new FormulationParser();
-      //foreach (var ci in intervalParam) {
-      //var inter = parser.Parse(ci.Formulation.GetValue());
-      //customIntervals.Add(ci.Variable.GetValue(), new Interval(0, 1));
-      //}
-      var resultInterval = interpreter.GetSymbolicExressionTreeIntervals(tree, Content.ProblemData.Dataset, Content.ProblemData.TrainingIndices, out intervals);
+      for (int x = 0; x < intervalParameters.Rows; ++x) {
+        customIntervals.Add(intervalParameters.RowNames.ElementAt(x),
+                            new Interval(intervalParameters.GetRow(x).ElementAt(0),
+                                         intervalParameters.GetRow(x).ElementAt(1)));
+      }
+
+      var resultInterval = interpreter.GetSymbolicExressionTreeIntervals(tree, Content.ProblemData.Dataset, Content.ProblemData.TrainingIndices, customIntervals, out intervals);
       await Task.Delay(500); // wait for progressbar to finish animation
       var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
@@ -206,18 +209,8 @@
         foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
       }
-      //Instruction currentInstr = instructions.NextInstruction();
-      //while (instructions.HasNextInstruction()) {
-      //  //intervals[currentInstr.dynamicNode] = (Interval)currentInstr.data;
-      //  intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
-      //  currentInstr = instructions.NextInstruction();
-      //}
-      
-      
-
-      //intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
+
       nodeImpacts = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item1);
       progress.Finish();
       PaintIntervals();
-      //PaintNodeImpacts();
     }
 
@@ -291,6 +284,5 @@
         if (visualTree != null) { 
           visualTree.ToolTip = visualTree.Content.ToString();
-          //visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[node].Item2.LowerBound:E4} ... {intervals[node].Item2.UpperBound:E4}]{Environment.NewLine}");
-          visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[treeNode].LowerBound:E4} ... {intervals[treeNode].UpperBound:E4}]{Environment.NewLine}]");
+          visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[treeNode].LowerBound:G5} ... {intervals[treeNode].UpperBound:G5}]{Environment.NewLine}");
           node++;
           
@@ -309,8 +301,8 @@
               visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
             }
-            visualTree.ToolTip += String.Format($"{Environment.NewLine} Node impact: {impact:E4}");
+            visualTree.ToolTip += String.Format($"Node impact: {impact:G5}");
             var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
             if (constantReplacementNode != null) {
-              visualTree.ToolTip += String.Format($"{Environment.NewLine} Replacement value: {constantReplacementNode.Value:E4}");
+              visualTree.ToolTip += String.Format($"{Environment.NewLine}Replacement value: {constantReplacementNode.Value:G5}");
             }
           }
