Changeset 18086 for branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

11/19/21 16:07:45 (3 years ago)

Author:

mkommend

Message:

#2521: Merged trunk changes into branch.

Location:

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Converters/DerivativeCalculator.cs (modified) (2 diffs)
• Converters/TreeSimplifier.cs (modified) (9 diffs)
• Converters/TreeToAutoDiffTermConverter.cs (modified) (2 diffs)
• Creators/MultiSymbolicDataAnalysisExpressionCreator.cs (modified) (4 diffs)
• Formatters/InfixExpressionFormatter.cs (modified) (3 diffs)
• Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs) (12 diffs)
• Grammars/LinearScalingGrammar.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (5 diffs)
• Importer/InfixExpressionParser.cs (modified) (3 diffs)
• Interfaces/IBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IBoundsEstimator.cs)
• Interpreter/IntervalArithBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs) (4 diffs)
• Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs) (3 diffs)
• Interpreter/IntervalInterpreter.cs (modified) (10 diffs)
• Interpreter/OpCodes.cs (modified) (1 diff)
• Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs (modified) (1 diff)
• Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs (modified) (1 diff)
• IntervalUtil.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs) (1 diff)
• Plugin.cs.frame (modified) (1 diff)
• SymbolicDataAnalysisMultiObjectiveProblem.cs (modified) (3 diffs)

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

@@ -149 +149 @@
         return Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName));
       }
+      if (branch.Symbol is Power) {
+        // HL evaluators handle power strangely (exponent is rounded to an integer)
+        // here we only support the case when the exponent is a constant integer 
+        var exponent = branch.GetSubtree(1) as ConstantTreeNode;
+        if (exponent != null && Math.Truncate(exponent.Value) == exponent.Value) {
+          var newPower = (ISymbolicExpressionTreeNode)branch.Clone();
+          var f = (ISymbolicExpressionTreeNode)newPower.GetSubtree(0).Clone();
+          var newExponent = (ConstantTreeNode)newPower.GetSubtree(1);
+          newExponent.Value -= 1;
+          return Product(Product(CreateConstant(exponent.Value), newPower), Derive(f, variableName));
+        } else throw new NotSupportedException("Cannot derive non-integer powers");
+      }
       if (branch.Symbol is Absolute) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
@@ -263 +275 @@
           !(n.Symbol is Cube) &&
           !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power) &&
           !(n.Symbol is Absolute) &&
           !(n.Symbol is AnalyticQuotient) &&
+          !(n.Symbol is HyperbolicTangent) &&
           !(n.Symbol is Sine) &&
           !(n.Symbol is Cosine) &&

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs

@@ -784 +784 @@
       } else if (IsExp(node)) {
         return MakeExp(MakeProduct(node.GetSubtree(0), MakeConstant(2.0))); // sqr(exp(x)) = exp(2x)
+      } else if (IsSquare(node)) {
+        return MakePower(node.GetSubtree(0), MakeConstant(4));
       } else if (IsCube(node)) {
         return MakePower(node.GetSubtree(0), MakeConstant(6));
@@ -809 +811 @@
       } else if (IsSquare(node)) {
         return MakePower(node.GetSubtree(0), MakeConstant(6));
+      } else if (IsCube(node)) {
+        return MakePower(node.GetSubtree(0), MakeConstant(9));
       } else {
         var cubeNode = cubeSymbol.CreateTreeNode();
@@ -933 +937 @@
         var constB = b as ConstantTreeNode;
         var constBValue = Math.Round(constB.Value);
-        if (constBValue.IsAlmost(1.0)) {
+        if (constBValue == 1.0) {
+          // root(a, 1) => a
           return a;
-        } else if (constBValue.IsAlmost(0.0)) {
-          return MakeConstant(1.0);
-        } else if (constBValue.IsAlmost(-1.0)) {
+        } else if (constBValue == 0.0) {
+          // root(a, 0) is not defined 
+          //return MakeConstant(1.0);
+          return MakeConstant(double.NaN);
+        } else if (constBValue == -1.0) {
+          // root(a, -1) => a^(-1/1) => 1/a
           return MakeFraction(MakeConstant(1.0), a);
         } else if (constBValue < 0) {
+          // root(a, -b) => a^(-1/b) => (1/a)^(1/b) => root(1, b) / root(a, b) => 1 / root(a, b)
           var rootNode = rootSymbol.CreateTreeNode();
           rootNode.AddSubtree(a);
@@ -987 +996 @@
         var constB = b as ConstantTreeNode;
         double exponent = Math.Round(constB.Value);
-        if (exponent.IsAlmost(0.0)) {
+        if (exponent == 0.0) {
+          // a^0 => 1
           return MakeConstant(1.0);
-        } else if (exponent.IsAlmost(1.0)) {
+        } else if (exponent == 1.0) {
+          // a^1 => a
           return a;
-        } else if (exponent.IsAlmost(-1.0)) {
+        } else if (exponent == -1.0) {
+          // a^-1 => 1/a
           return MakeFraction(MakeConstant(1.0), a);
         } else if (exponent < 0) {
+          // a^-b => (1/a)^b => 1/(a^b)
           var powNode = powSymbol.CreateTreeNode();
           powNode.AddSubtree(a);
@@ -1018 +1031 @@
         // fold constants
         return MakeConstant(((ConstantTreeNode)a).Value / ((ConstantTreeNode)b).Value);
-      } else if ((IsConstant(a) && !((ConstantTreeNode)a).Value.IsAlmost(1.0))) {
+      } else if ((IsConstant(a) && ((ConstantTreeNode)a).Value != 1.0)) {
+        // a / x => (a * 1/a) / (x * 1/a) => 1 / (x * 1/a)
         return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
       } else if (IsVariableBase(a) && IsConstant(b)) {
@@ -1094 +1108 @@
         // b is not constant => make sure constant is on the right
         return MakeSum(b, a);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value.IsAlmost(0.0)) {
+      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
         // x + 0 => x
         return a;
@@ -1210 +1224 @@
       foreach (var unchangedSubtree in unchangedSubtrees)
         sum.AddSubtree(unchangedSubtree);
-      if (!constant.IsAlmost(0.0)) {
+      if (constant != 0.0) {
         sum.AddSubtree(MakeConstant(constant));
       }
@@ -1268 +1282 @@
         if (wi < 0) throw new ArgumentException();
         return MakeBinFactor(node1.Symbol, node1.VariableName, node1.VariableValue, node1.Weight * node0.Weights[wi]);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value.IsAlmost(1.0)) {
+      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 1.0) {
         // $ * 1.0 => $
         return a;
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value.IsAlmost(0.0)) {
+      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
         return MakeConstant(0);
       } else if (IsConstant(b) && IsVariableBase(a)) {
@@ -1419 +1433 @@
         prod.AddSubtree(unchangedSubtree);
 
-      if (!constantProduct.IsAlmost(1.0)) {
+      if (constantProduct != 1.0) {
         prod.AddSubtree(MakeConstant(constantProduct));
       }

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs

@@ -258 +258 @@
       if (node.Symbol is CubeRoot) {
         return cbrt(ConvertToAutoDiff(node.GetSubtree(0)));
+      }
+      if (node.Symbol is Power) {
+        var powerNode = node.GetSubtree(1) as ConstantTreeNode;
+        if (powerNode == null)
+          throw new NotSupportedException("Only integer powers are allowed in parameter optimization. Try to use exp() and log() instead of the power symbol.");
+        var intPower = Math.Truncate(powerNode.Value);
+        if (intPower != powerNode.Value)
+          throw new NotSupportedException("Only integer powers are allowed in parameter optimization. Try to use exp() and log() instead of the power symbol.");
+        return AutoDiff.TermBuilder.Power(ConvertToAutoDiff(node.GetSubtree(0)), intPower);
       }
       if (node.Symbol is Sine) {
@@ -340 +349 @@
           !(n.Symbol is AnalyticQuotient) &&
           !(n.Symbol is Cube) &&
-          !(n.Symbol is CubeRoot)
+          !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power)
         select n).Any();
       return !containsUnknownSymbol;

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Creators/MultiSymbolicDataAnalysisExpressionCreator.cs

@@ -44 +44 @@
     private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
     private const string SymbolicExpressionTreeGrammarParameterName = "SymbolicExpressionTreeGrammar";
-    private const string ClonedSymbolicExpressionTreeGrammarParameterName = "ClonedSymbolicExpressionTreeGrammar";
 
     public override bool CanChangeName {
@@ -66 +65 @@
       get { return (IValueLookupParameter<ISymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
     }
-    public ILookupParameter<ISymbolicExpressionGrammar> ClonedSymbolicExpressionTreeGrammarParameter {
-      get { return (ILookupParameter<ISymbolicExpressionGrammar>)Parameters[ClonedSymbolicExpressionTreeGrammarParameterName]; }
-    }
     #endregion
 
@@ -80 +76 @@
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));
-      Parameters.Add(new LookupParameter<ISymbolicExpressionGrammar>(ClonedSymbolicExpressionTreeGrammarParameterName, "An immutable clone of the concrete grammar that is actually used to create and manipulate trees."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, "The tree grammar that defines the correct syntax of symbolic expression trees that should be created."));      
 
       List<ISymbolicDataAnalysisSolutionCreator> list = new List<ISymbolicDataAnalysisSolutionCreator>();
@@ -96 +91 @@
     }
 
-    public override IOperation InstrumentedApply() {
-      if (ClonedSymbolicExpressionTreeGrammarParameter.ActualValue == null) {
-        SymbolicExpressionTreeGrammarParameter.ActualValue.ReadOnly = true;
-        IScope globalScope = ExecutionContext.Scope;
-        while (globalScope.Parent != null)
-          globalScope = globalScope.Parent;
-
-        globalScope.Variables.Add(new Core.Variable(ClonedSymbolicExpressionTreeGrammarParameterName, (ISymbolicExpressionGrammar)SymbolicExpressionTreeGrammarParameter.ActualValue.Clone()));
-      }
-      return base.InstrumentedApply();
-    }
 
     public ISymbolicExpressionTree CreateTree(IRandom random, ISymbolicExpressionGrammar grammar, int maxTreeLength, int maxTreeDepth) {

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs

@@ -38 +38 @@
         // operators
         if (token == "+" || token == "-" || token == "OR" || token == "XOR" ||
-            token == "*" || token == "/" || token == "AND" ||
-            token == "^") {
+            token == "*" || token == "/" || token == "AND") {
           strBuilder.Append("(");
           FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, constants);
@@ -46 +45 @@
             strBuilder.Append(" ").Append(token).Append(" ");
             FormatRecursively(subtree, strBuilder, numberFormat, formatString, constants);
+          }
+
+          strBuilder.Append(")");
+        } else if (token == "^") {
+          // handle integer powers directly
+          strBuilder.Append("(");
+          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, constants);
+
+          var power = node.GetSubtree(1);
+          if(power is ConstantTreeNode constNode && Math.Truncate(constNode.Value) == constNode.Value) {
+            strBuilder.Append(" ").Append(token).Append(" ").Append(constNode.Value.ToString(formatString, numberFormat));
+          } else {
+            strBuilder.Append(" ").Append(token).Append(" ");
+            FormatRecursively(power, strBuilder, numberFormat, formatString, constants);
           }
 
@@ -83 +96 @@
           if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            if (constants != null) {
-              strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
-            } else {
-              strBuilder.Append(varNode.Weight.ToString(formatString, numberFormat));
-            }
+            AppendConstant(strBuilder, constants, varNode.Weight, formatString, numberFormat);
             strBuilder.Append("*");
           }
 
           strBuilder.Append("LAG(");
-          if (varNode.VariableName.Contains("'"))
-            strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
-          else
-            strBuilder.AppendFormat("'{0}'", varNode.VariableName);
-
+          AppendVariableName(strBuilder, varNode.VariableName);
           strBuilder.Append(", ")
                     .AppendFormat(numberFormat, "{0}", varNode.Lag)
                     .Append(")");
+          if (!varNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
         } else if (node.Symbol is Variable) {
           var varNode = node as VariableTreeNode;
           if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            if (constants != null) {
-              string constantKey = $"c_{constants.Count}";
-              strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constantKey);
-              constants.Add(new KeyValuePair<string, double>(constantKey, varNode.Weight));
-            } else {
-              strBuilder.Append(varNode.Weight.ToString(formatString, numberFormat));
-            }
-
+            AppendConstant(strBuilder, constants, varNode.Weight, formatString, numberFormat);
             strBuilder.Append("*");
           }
 
-          if (varNode.VariableName.Contains("'"))
-            strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
-          else
-            strBuilder.AppendFormat("'{0}'", varNode.VariableName);
+          AppendVariableName(strBuilder, varNode.VariableName);
 
           if (!varNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
         } else if (node.Symbol is FactorVariable) {
           var factorNode = node as FactorVariableTreeNode;
-          if (factorNode.VariableName.Contains("'"))
-            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
-          else
-            strBuilder.AppendFormat("'{0}'", factorNode.VariableName);
-
-          strBuilder.AppendFormat("[{0}]",
-            string.Join(", ", factorNode.Weights.Select(w => w.ToString(formatString, numberFormat))));
+          AppendVariableName(strBuilder, factorNode.VariableName);
+
+          strBuilder.Append("[");
+          for (int i = 0; i < factorNode.Weights.Length; i++) {
+            if (i > 0) strBuilder.Append(", ");
+            AppendConstant(strBuilder, constants, factorNode.Weights[i], formatString, numberFormat);
+          }
+          strBuilder.Append("]");
         } else if (node.Symbol is BinaryFactorVariable) {
           var factorNode = node as BinaryFactorVariableTreeNode;
           if (!factorNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            if (constants != null) {
-              strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", factorNode.Weight);
-            } else {
-              strBuilder.Append(factorNode.Weight.ToString(formatString, numberFormat));
-            }
+            AppendConstant(strBuilder, constants, factorNode.Weight, formatString, numberFormat);
 
             strBuilder.Append("*");
           }
 
-          if (factorNode.VariableName.Contains("'"))
-            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
-          else
-            strBuilder.AppendFormat("'{0}'", factorNode.VariableName);
-
+          AppendVariableName(strBuilder, factorNode.VariableName);
           strBuilder.Append(" = ");
-          if (factorNode.VariableValue.Contains("'"))
-            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableValue);
-          else
-            strBuilder.AppendFormat("'{0}'", factorNode.VariableValue);
+          AppendVariableName(strBuilder, factorNode.VariableValue);
 
           if (!factorNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
         } else if (node.Symbol is Constant) {
           var constNode = node as ConstantTreeNode;
-          if (constants != null) {
-            string constantKey = $"c_{constants.Count}";
-
-            strBuilder.AppendFormat(CultureInfo.InvariantCulture, constantKey);
-            constants.Add(new KeyValuePair<string, double>(constantKey, constNode.Value));
+          if (constants == null && constNode.Value < 0) {
+            strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat))
+                      .Append(")"); // (-1
           } else {
-            if (constNode.Value >= 0.0)
-              strBuilder.Append(constNode.Value.ToString(formatString, numberFormat));
-            else
-              strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat))
-                        .Append(")"); // (-1
+            AppendConstant(strBuilder, constants, constNode.Value, formatString, numberFormat);
           }
         }
       }
+    }
+
+    private static void AppendConstant(StringBuilder strBuilder, List<KeyValuePair<string, double>> constants, double value, string formatString, NumberFormatInfo numberFormat) {
+      if (constants != null) {
+        string constantKey = $"c_{constants.Count}";
+        strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constantKey);
+        constants.Add(new KeyValuePair<string, double>(constantKey, value));
+      } else {
+        strBuilder.Append(value.ToString(formatString, numberFormat));
+      }
+    }
+
+    private static void AppendVariableName(StringBuilder strBuilder, string name) {
+      if (name.Contains("'"))
+        strBuilder.AppendFormat("\"{0}\"", name);
+      else
+        strBuilder.AppendFormat("'{0}'", name);
     }
 

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

@@ -154 +154 @@
           strBuilder.Append(" / Math.Sqrt(1 + Math.Pow(");
           FormatRecursively(node.GetSubtree(1), strBuilder);
-          strBuilder.Append(" , 2) )");
+          strBuilder.Append(" , 2) ) )");
         } else {
           throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

@@ -517 +517 @@
 
     private void FormatStartSymbol(StringBuilder strBuilder) {
-      strBuilder.Append(targetVariable ?? "target_" + (targetCount++));
+      strBuilder.Append(targetVariable != null ? EscapeLatexString(targetVariable) : "\\text{target}_{" + targetCount++ + "}");
       if (containsTimeSeriesSymbol)
         strBuilder.Append("(t)");

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs

@@ -58 +58 @@
     }
 
-    private string GenerateHeader(ISymbolicExpressionTree symbolicExpressionTree) {
+    private static string GenerateHeader(ISymbolicExpressionTree symbolicExpressionTree) {
       StringBuilder strBuilder = new StringBuilder();
 
@@ -102 +102 @@
     }
 
-    private string GenerateNecessaryImports(int mathLibCounter, int statisticLibCounter) {
+    private static string GenerateNecessaryImports(int mathLibCounter, int statisticLibCounter) {
       StringBuilder strBuilder = new StringBuilder();
       if (mathLibCounter > 0 || statisticLibCounter > 0) {
@@ -115 +115 @@
     }
 
-    private string GenerateIfThenElseSource(int evaluateIfCounter) {
+    private static string GenerateIfThenElseSource(int evaluateIfCounter) {
       StringBuilder strBuilder = new StringBuilder();
       if (evaluateIfCounter > 0) {
@@ -128 +128 @@
     }
 
-    private string GenerateModelEvaluationFunction(ISet<string> variables) {
+    private static string GenerateModelEvaluationFunction(ISet<string> variables) {
       StringBuilder strBuilder = new StringBuilder();
       strBuilder.Append("def evaluate(");
@@ -142 +142 @@
     }
 
-    private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       ISymbol symbol = node.Symbol;
       if (symbol is ProgramRootSymbol)
@@ -208 +208 @@
     }
 
-    private string VariableName2Identifier(string variableName) => variableName.Replace(" ", "_");
-
-    private void FormatNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string prefixSymbol = "", string openingSymbol = "(", string closingSymbol = ")", string infixSymbol = ",") {
+    private static string VariableName2Identifier(string variableName) => variableName.Replace(" ", "_");
+
+    private static void FormatNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string prefixSymbol = "", string openingSymbol = "(", string closingSymbol = ")", string infixSymbol = ",") {
       strBuilder.Append($"{prefixSymbol}{openingSymbol}");
       foreach (var child in node.Subtrees) {
@@ -220 +220 @@
     }
 
-    private void FormatVariableTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatVariableTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       var varNode = node as VariableTreeNode;
       var formattedVariable = VariableName2Identifier(varNode.VariableName);
@@ -227 +227 @@
     }
 
-    private void FormatConstantTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatConstantTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       var constNode = node as ConstantTreeNode;
       strBuilder.Append(constNode.Value.ToString("g17", CultureInfo.InvariantCulture));
     }
 
-    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
+    private static void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
       strBuilder.Append("math.pow(");
       FormatRecursively(node.GetSubtree(0), strBuilder);
@@ -238 +238 @@
     }
 
-    private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       strBuilder.Append("math.pow(");
       FormatRecursively(node.GetSubtree(0), strBuilder);
@@ -246 +246 @@
     }
 
-    private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       if (node.SubtreeCount == 1) {
         strBuilder.Append("-");
@@ -256 +256 @@
     }
 
-    private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       strBuilder.Append("(");
       if (node.SubtreeCount == 1) {
@@ -273 +273 @@
     }
 
-    private void FormatAnalyticQuotient(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private static void FormatAnalyticQuotient(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       strBuilder.Append("(");
       FormatRecursively(node.GetSubtree(0), strBuilder);

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -99 +99 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <HintPath>..\..\bin\ALGLIB-3.7.0.dll</HintPath>
+    <Reference Include="ALGLIB-3.17.0, Version=3.17.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\bin\ALGLIB-3.17.0.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -107 +108 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+    <Reference Include="HEAL.Attic, Version=1.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\bin\HEAL.Attic.dll</HintPath>
@@ -153 +154 @@
     <Compile Include="Crossovers\SymbolicDataAnalysisExpressionDiversityPreservingCrossover.cs" />
     <Compile Include="Formatters\InfixExpressionFormatter.cs" />
+    <Compile Include="Formatters\SymbolicDataAnalysisExpressionPythonFormatter.cs" />
     <Compile Include="Formatters\TSQLExpressionFormatter.cs" />
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionMathematicaFormatter.cs" />
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionCSharpFormatter.cs" />
     <Compile Include="Grammars\DataAnalysisGrammar.cs" />
+    <Compile Include="Grammars\LinearScalingGrammar.cs" />
     <Compile Include="Hashing\HashExtensions.cs" />
     <Compile Include="Hashing\HashUtil.cs" />
@@ -163 +166 @@
     <Compile Include="Importer\SymbolicExpressionImporter.cs" />
     <Compile Include="Importer\Token.cs" />
+    <Compile Include="Interfaces\IBoundsEstimator.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
     <Compile Include="Interfaces\IVariableTreeNode.cs" />
@@ -168 +172 @@
     <Compile Include="Interpreter\BatchInstruction.cs" />
     <Compile Include="Interpreter\BatchOperations.cs" />
+    <Compile Include="Interpreter\IntervalArithBoundsEstimator.cs" />
+    <Compile Include="Interpreter\IntervalArithCompiledExpressionBoundsEstimator.cs" />
     <Compile Include="Interpreter\IntervalInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs" />
+    <Compile Include="IntervalUtil.cs" />
     <Compile Include="Selectors\DiversitySelector.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionTreeAverageSimilarityCalculator.cs" />

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs

@@ -64 +64 @@
     }
 
-    private class SymbolNameComparer : IEqualityComparer<ISymbol>, IComparer<ISymbol> {
+    private class SymbolComparer : IEqualityComparer<ISymbol>, IComparer<ISymbol> {
       public int Compare(ISymbol x, ISymbol y) {
         return x.Name.CompareTo(y.Name);
@@ -70 +70 @@
 
       public bool Equals(ISymbol x, ISymbol y) {
-        return Compare(x, y) == 0;
+        return x.GetType() == y.GetType();
       }
 
       public int GetHashCode(ISymbol obj) {
-        return obj.Name.GetHashCode();
+        return obj.GetType().GetHashCode();
       }
     }
@@ -80 +80 @@
     // the lookup table is also used in the corresponding formatter
     internal static readonly BidirectionalLookup<string, ISymbol>
-      knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolNameComparer());
+      knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolComparer());
 
     private Constant constant = new Constant();

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs

@@ -53 +53 @@
     private IntervalArithBoundsEstimator(StorableConstructorFlag _) : base(_) { }
 
-    private IntervalArithBoundsEstimator(IntervalArithBoundsEstimator original, Cloner cloner) : base(original, cloner) { }
+    protected IntervalArithBoundsEstimator(IntervalArithBoundsEstimator original, Cloner cloner) : base(original, cloner) { }
 
     public IntervalArithBoundsEstimator() : base("Interval Arithmetic Bounds Estimator",
@@ -223 +223 @@
             break;
           }
+        case OpCodes.Power: {
+          var a = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+          var b = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+          // support only integer powers
+          if (b.LowerBound == b.UpperBound && Math.Truncate(b.LowerBound) == b.LowerBound) {
+            result = Interval.Power(a, (int)b.LowerBound);
+          } else {
+            throw new NotSupportedException("Interval is only supported for integer powers");
+          }
+          break;
+        }
         case OpCodes.Absolute: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
@@ -232 +243 @@
             for (var i = 1; i < currentInstr.nArguments; i++) {
               var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
-              result = Interval.AnalyticalQuotient(result, argumentInterval);
+              result = Interval.AnalyticQuotient(result, argumentInterval);
             }
 
@@ -329 +340 @@
           !(n.Symbol is Cube) &&
           !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power) &&
           !(n.Symbol is Absolute) &&
           !(n.Symbol is AnalyticQuotient)

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs

@@ -75 +75 @@
 
     [StorableConstructor]
-    private IntervalArithCompiledExpressionBoundsEstimator(StorableConstructorFlag _) : base(_) { }
-
-    private IntervalArithCompiledExpressionBoundsEstimator(IntervalArithCompiledExpressionBoundsEstimator original, Cloner cloner) : base(original, cloner) { }
+    protected IntervalArithCompiledExpressionBoundsEstimator(StorableConstructorFlag _) : base(_) { }
+
+    protected IntervalArithCompiledExpressionBoundsEstimator(IntervalArithCompiledExpressionBoundsEstimator original, Cloner cloner) : base(original, cloner) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -194 +194 @@
             return Expression.Divide(e1, e2);
           }
+        case OpCodes.AnalyticQuotient: {
+            var a = expr(node.GetSubtree(0));
+            var b = expr(node.GetSubtree(1));
+            var fun = typeof(Interval).GetMethod(methodName[opCode], new[] { a.Type, b.Type });
+            return Expression.Call(fun, a, b);
+          }
         // all these cases share the same code: get method info by name, emit call expression
         case OpCodes.Exp:
@@ -205 +211 @@
         case OpCodes.SquareRoot:
         case OpCodes.CubeRoot:
-        case OpCodes.Absolute:
-        case OpCodes.AnalyticQuotient: {
+        case OpCodes.Absolute: {
             var arg = expr(node.GetSubtree(0));
             var fun = typeof(Interval).GetMethod(methodName[opCode], new[] { arg.Type });

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -1 +1 @@
 #region License Information
+
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18 +19 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #endregion
 
@@ -32 +34 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableType("DE6C1E1E-D7C1-4070-847E-63B68562B10C")]
-  [Item("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.")]
+  [Item("IntervalInterpreter", "Interpreter for calculation of intervals of symbolic models.")]
   public sealed class IntervalInterpreter : ParameterizedNamedItem, IStatefulItem {
-
     private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
-
-    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
-    }
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter =>
+      (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
 
     public int EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value.Value; }
-      set { EvaluatedSolutionsParameter.Value.Value = value; }
+      get => EvaluatedSolutionsParameter.Value.Value;
+      set => EvaluatedSolutionsParameter.Value.Value = value;
     }
 
     [StorableConstructor]
     private IntervalInterpreter(StorableConstructorFlag _) : base(_) { }
+
     private IntervalInterpreter(IntervalInterpreter original, Cloner cloner)
-        : base(original, cloner) { }
+      : base(original, cloner) { }
 
     public IntervalInterpreter()
-        : base("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.") {
-      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      : base("IntervalInterpreter", "Interpreter for calculation of intervals of symbolic models.") {
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName,
+        "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     }
 
@@ -63 +64 @@
 
     #region IStatefulItem Members
+
     public void InitializeState() {
       EvaluatedSolutions = 0;
     }
+
     public void ClearState() { }
+
     #endregion
 
-    public Interval GetSymbolicExpressionTreeInterval(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 GetSymbolicExpressionTreeInterval(tree, variableRanges);
     }
 
-    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
-      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeIntervals(
+      ISymbolicExpressionTree tree, IDataset dataset,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval>
+        nodeIntervals, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
       return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
     }
 
-    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
+    public Interval GetSymbolicExpressionTreeInterval(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
       }
-      int instructionCount = 0;
+
+      Interval outputInterval;
+
+      var instructionCount = 0;
       var instructions = PrepareInterpreterState(tree, variableRanges);
-      var outputInterval = Evaluate(instructions, ref instructionCount);
-
-      // because of numerical errors the bounds might be incorrect
-      if (outputInterval.LowerBound <= outputInterval.UpperBound)
-        return outputInterval;
-      else
-        return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
-    }
-
-
-    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
-      IReadOnlyDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+      outputInterval = Evaluate(instructions, ref instructionCount);
+
+      return outputInterval.LowerBound <= outputInterval.UpperBound
+        ? outputInterval
+        : new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
+    }
+
+
+    public Interval GetSymbolicExpressionTreeIntervals(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval>
+        nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
       }
-      int instructionCount = 0;
+
       var intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       var instructions = PrepareInterpreterState(tree, variableRanges);
-      var outputInterval = Evaluate(instructions, ref instructionCount, intervals);
-
-      // fix incorrect intervals if necessary (could occur because of numerical errors)
+
+      Interval outputInterval;
+      var instructionCount = 0;
+      outputInterval = Evaluate(instructions, ref instructionCount, intervals);
+
       nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       foreach (var kvp in intervals) {
@@ -119 +135 @@
       if (outputInterval.IsInfiniteOrUndefined || outputInterval.LowerBound <= outputInterval.UpperBound)
         return outputInterval;
-      else
-        return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
-    }
-
-
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
+
+      return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
+    }
+
+
+    private static Instruction[] PrepareInterpreterState(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
 
-      //Check if all variables used in the tree are present in the dataset
-      foreach (var variable in tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(n => n.VariableName).Distinct()) {
-        if (!variableRanges.ContainsKey(variable)) throw new InvalidOperationException($"No ranges for variable {variable} is present");
-      }
-
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
+      // Check if all variables used in the tree are present in the dataset
+      foreach (var variable in tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(n => n.VariableName)
+                                   .Distinct())
+        if (!variableRanges.ContainsKey(variable))
+          throw new InvalidOperationException($"No ranges for variable {variable} is present");
+
+      var code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      foreach (var instr in code.Where(i => i.opCode == OpCodes.Variable)) {
         var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
         instr.data = variableRanges[variableTreeNode.VariableName];
       }
+
       return code;
     }
 
-    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
-      //Update instructionCounter, whenever Evaluate is called
+    // Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
+    // Update instructionCounter, whenever Evaluate is called
+    public static Interval Evaluate(
+    Instruction[] instructions, ref int instructionCounter,
+      IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null,
+      IReadOnlyDictionary<string, Interval> variableIntervals = null) {
+      var currentInstr = instructions[instructionCounter];
+
       instructionCounter++;
-      Interval result = null;
+      Interval result;
 
       switch (currentInstr.opCode) {
-        //Variables, Constants, ...
         case OpCodes.Variable: {
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
-            var variableInterval = (Interval)currentInstr.data;
+
+            Interval variableInterval;
+            if (variableIntervals != null && variableIntervals.ContainsKey(variableTreeNode.VariableName))
+              variableInterval = variableIntervals[variableTreeNode.VariableName];
+            else
+              variableInterval = (Interval)currentInstr.data;
 
             result = Interval.Multiply(variableInterval, weightInterval);
@@ -163 +191 @@
             break;
           }
-        //Elementary arithmetic rules
         case OpCodes.Add: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Add(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Sub: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             if (currentInstr.nArguments == 1)
               result = Interval.Multiply(new Interval(-1, -1), result);
 
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Subtract(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Mul: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Multiply(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Div: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             if (currentInstr.nArguments == 1)
               result = Interval.Divide(new Interval(1, 1), result);
 
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Divide(result, argumentInterval);
             }
-            break;
-          }
-        //Trigonometric functions
+
+            break;
+          }
         case OpCodes.Sin: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Sine(argumentInterval);
             break;
           }
         case OpCodes.Cos: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Cosine(argumentInterval);
             break;
           }
         case OpCodes.Tan: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Tangens(argumentInterval);
             break;
           }
         case OpCodes.Tanh: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.HyperbolicTangent(argumentInterval);
             break;
           }
-        //Exponential functions
         case OpCodes.Log: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Logarithm(argumentInterval);
             break;
           }
         case OpCodes.Exp: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Exponential(argumentInterval);
             break;
           }
         case OpCodes.Square: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Square(argumentInterval);
             break;
           }
         case OpCodes.SquareRoot: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.SquareRoot(argumentInterval);
             break;
           }
         case OpCodes.Cube: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Cube(argumentInterval);
             break;
           }
         case OpCodes.CubeRoot: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.CubicRoot(argumentInterval);
             break;
           }
+        case OpCodes.Power: {
+            var a = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            var b = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            // support only integer powers
+            if (b.LowerBound == b.UpperBound && Math.Truncate(b.LowerBound) == b.LowerBound) {
+              result = Interval.Power(a, (int)b.LowerBound);
+            } else {
+              throw new NotSupportedException("Interval is only supported for integer powers");
+            }
+            break;
+          }
+
         case OpCodes.Absolute: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             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);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+              result = Interval.AnalyticQuotient(result, argumentInterval);
             }
 
@@ -272 +313 @@
       }
 
-      if (nodeIntervals != null)
+      if (!(nodeIntervals == null || nodeIntervals.ContainsKey(currentInstr.dynamicNode)))
         nodeIntervals.Add(currentInstr.dynamicNode, result);
 
@@ -278 +319 @@
     }
 
+
     public static bool IsCompatible(ISymbolicExpressionTree tree) {
-      var containsUnknownSyumbol = (
-        from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
-        where
-          !(n.Symbol is Problems.DataAnalysis.Symbolic.Variable) &&
+      foreach (var n in tree.Root.GetSubtree(0).IterateNodesPrefix()) {
+        if (
+          !(n.Symbol is Variable) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
@@ -292 +333 @@
           !(n.Symbol is Cosine) &&
           !(n.Symbol is Tangent) &&
+          !(n.Symbol is HyperbolicTangent) &&
           !(n.Symbol is Logarithm) &&
           !(n.Symbol is Exponential) &&
@@ -298 +340 @@
           !(n.Symbol is Cube) &&
           !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power) &&
           !(n.Symbol is Absolute) &&
-          !(n.Symbol is AnalyticQuotient)
-        select n).Any();
-      return !containsUnknownSyumbol;
+          !(n.Symbol is AnalyticQuotient)) return false;
+
+        else if (n.Symbol is Power) {
+          // only integer exponents are supported
+          var exp = n.GetSubtree(1) as ConstantTreeNode;
+          if (exp == null || exp.Value != Math.Truncate(exp.Value)) return false;
+        }
+      }
+      return true;
     }
   }

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -144 +144 @@
       { typeof(Cosine), OpCodes.Cos },
       { typeof(Tangent), OpCodes.Tan },
-      { typeof (HyperbolicTangent), OpCodes.Tanh},
+      { typeof(HyperbolicTangent), OpCodes.Tanh},
       { typeof(Logarithm), OpCodes.Log },
       { typeof(Exponential), OpCodes.Exp },

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

@@ -222 +222 @@
 
     private double[] GetValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
-      if (cachedData == null || cachedDataset != dataset) {
+      if (cachedData == null || cachedDataset != dataset || cachedDataset is ModifiableDataset) {
         InitCache(dataset);
       }

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

@@ -127 +127 @@
       if (!rows.Any()) return Enumerable.Empty<double>();
 
-      if (cachedData == null || cachedDataset != dataset) {
+      if (cachedData == null || cachedDataset != dataset || cachedDataset is ModifiableDataset) {
         InitCache(dataset);
       }

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs

@@ -39 +39 @@
       var varRanges = variableRanges.GetReadonlyDictionary();
 
-      if (constraint.Variable != null && !varRanges.ContainsKey(constraint.Variable)) {
+      if (!string.IsNullOrEmpty(constraint.Variable) && !varRanges.ContainsKey(constraint.Variable)) {
         throw new ArgumentException(
-          $"The given variable {constraint.Variable} in the constraint does not exist in the model.",
+          $"No variable range found for variable {constraint.Variable} used in the constraints.",
           nameof(constraint));
       }

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame

@@ -28 +28 @@
   [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.12.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.ALGLIB", "3.7.0")]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.17.0")]
   [PluginDependency("HeuristicLab.AutoDiff", "1.0")]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]

branches/2521_ProblemRefactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisMultiObjectiveProblem.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -32 +33 @@
   [StorableType("E9876DF8-ACFA-41C8-93B7-FA40C57CE459")]
   public abstract class SymbolicDataAnalysisMultiObjectiveProblem<T, U> : SymbolicDataAnalysisProblem<T, U>, ISymbolicDataAnalysisMultiObjectiveProblem
-    where T : class,IDataAnalysisProblemData
+    where T : class, IDataAnalysisProblemData
     where U : class, ISymbolicDataAnalysisMultiObjectiveEvaluator<T> {
     private const string MaximizationParameterName = "Maximization";
@@ -102 +103 @@
         op.MaximizationParameter.ActualName = MaximizationParameterName;
       }
+
+      // these two crossover operators are compatible with single-objective problems only so we remove them from the operators collection
+      bool pred(IItem x) {
+        return x is SymbolicDataAnalysisExpressionDeterministicBestCrossover<T> || x is SymbolicDataAnalysisExpressionContextAwareCrossover<T>;
+      };
+      Operators.RemoveAll(pred);
+      // if a multi crossover is present, remove them from its operator collection
+      var cx = Operators.FirstOrDefault(x => x is MultiSymbolicDataAnalysisExpressionCrossover<T>);
+      if (cx != null) {
+        var multiCrossover = (MultiSymbolicDataAnalysisExpressionCrossover<T>)cx;
+        var items = multiCrossover.Operators.Where(pred).Cast<ISymbolicExpressionTreeCrossover>().ToList();
+        foreach (var item in items) {
+          multiCrossover.Operators.Remove(item);
+        }
+      }
     }