Index: branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs
===================================================================
--- branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 16722)
+++ branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 16899)
@@ -69,16 +69,16 @@
     #endregion
 
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeInterval(tree, variableRanges);
-    }
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
-      out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
+      return GetSymbolicExpressionTreeInterval(tree, variableRanges);
+    }
+
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeIntervals(tree, variableRanges, out nodeIntervals);
-    }
-
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+      return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
+    }
+
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -96,6 +96,6 @@
 
 
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree,
-      Dictionary<string, Interval> variableRanges, out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
+      IDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -108,5 +108,5 @@
       // fix incorrect intervals if necessary (could occur because of numerical errors)
       nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      foreach(var kvp in intervals) {
+      foreach (var kvp in intervals) {
         var interval = kvp.Value;
         if (interval.IsInfiniteOrUndefined || interval.LowerBound <= interval.UpperBound)
@@ -124,5 +124,5 @@
 
 
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
@@ -133,6 +133,6 @@
       }
 
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
+      foreach (Instruction instr in code.Where(i => i.opCode == OpCode.Variable)) {
         var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
         instr.data = variableRanges[variableTreeNode.VariableName];
@@ -141,5 +141,5 @@
     }
 
-    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
+    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
       Instruction currentInstr = instructions[instructionCounter];
       //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
@@ -150,5 +150,5 @@
       switch (currentInstr.opCode) {
         //Variables, Constants, ...
-        case OpCodes.Variable: {
+        case OpCode.Variable: {
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
@@ -158,5 +158,5 @@
             break;
           }
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             result = new Interval(constTreeNode.Value, constTreeNode.Value);
@@ -164,5 +164,5 @@
           }
         //Elementary arithmetic rules
-        case OpCodes.Add: {
+        case OpCode.Add: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172,5 +172,5 @@
             break;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -183,5 +183,5 @@
             break;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -191,5 +191,5 @@
             break;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -203,31 +203,36 @@
           }
         //Trigonometric functions
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Sine(argumentInterval);
             break;
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Cosine(argumentInterval);
             break;
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Tangens(argumentInterval);
             break;
           }
+        case OpCode.Tanh: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.HyperbolicTangent(argumentInterval);
+            break;
+          }
         //Exponential functions
-        case OpCodes.Log: {
+        case OpCode.Log: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Logarithm(argumentInterval);
             break;
           }
-        case OpCodes.Exp: {
+        case OpCode.Exp: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Exponential(argumentInterval);
             break;
           }
-        case OpCodes.Power: {
+        case OpCode.Power: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -237,10 +242,10 @@
             break;
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Square(argumentInterval);
             break;
           }
-        case OpCodes.Root: {
+        case OpCode.Root: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -250,5 +255,5 @@
             break;
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.SquareRoot(argumentInterval);
