Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 17103)
@@ -143,5 +143,5 @@
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName));
+        return Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
       }
       if (branch.Symbol is Cube) {
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 17103)
@@ -92,4 +92,11 @@
       );
 
+    private static readonly Func<Term, UnaryFunc> cbrt = UnaryFunc.Factory(
+      eval: x => x < 0 ? -Math.Pow(-x, 1.0 / 3) : Math.Pow(x, 1.0 / 3),
+      diff: x => { var cbrt_x = x < 0 ? -Math.Pow(-x, 1.0 / 3) : Math.Pow(x, 1.0 / 3); return 1.0 / (3 * cbrt_x * cbrt_x); }
+      );
+
+
+
     #endregion
 
@@ -250,6 +257,5 @@
       }
       if (node.Symbol is CubeRoot) {
-        return AutoDiff.TermBuilder.Power(
-          ConvertToAutoDiff(node.GetSubtree(0)), 1.0/3.0);
+        return cbrt(ConvertToAutoDiff(node.GetSubtree(0)));
       }
       if (node.Symbol is Sine) {
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 17103)
@@ -137,8 +137,22 @@
         } else if (node.Symbol is SquareRoot) {
           FormatFunction(node, "Math.Sqrt", strBuilder);
+        } else if (node.Symbol is Cube) {
+          FormatPower(node, strBuilder, "3");
+        } else if (node.Symbol is CubeRoot) {
+          strBuilder.Append("Cbrt(");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(")");
         } else if (node.Symbol is Power) {
           FormatFunction(node, "Math.Pow", strBuilder);
         } else if (node.Symbol is Root) {
           FormatRoot(node, strBuilder);
+        } else if (node.Symbol is Absolute) {
+          FormatFunction(node, "Math.Abs", strBuilder);
+        } else if (node.Symbol is AnalyticQuotient) {
+          strBuilder.Append("(");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(" / Math.Sqrt(1 + Math.Pow(");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append(" , 2) )");
         } else {
           throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");
@@ -173,7 +187,10 @@
 
     private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      FormatPower(node, strBuilder, "2");
+    }
+    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
       strBuilder.Append("Math.Pow(");
       FormatRecursively(node.GetSubtree(0), strBuilder);
-      strBuilder.Append(", 2)");
+      strBuilder.Append($", {exponent})");
     }
 
@@ -237,4 +254,5 @@
       strBuilder.AppendLine("public static class Model {");
       GenerateAverageSource(strBuilder);
+      GenerateCbrtSource(strBuilder);
       GenerateIfThenElseSource(strBuilder);
       GenerateFactorSource(strBuilder);
@@ -278,4 +296,9 @@
       strBuilder.AppendLine("private static double Average(params double[] values) {");
       strBuilder.AppendLine("  return values.Average();");
+      strBuilder.AppendLine("}");
+    }
+    private void GenerateCbrtSource(StringBuilder strBuilder) {
+      strBuilder.AppendLine("private static double Cbrt(double x) {");
+      strBuilder.AppendLine("  return x < 0 ? -Math.Pow(-x, 1.0 / 3.0) : Math.Pow(x, 1.0 / 3.0);");
       strBuilder.AppendLine("}");
     }
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs	(revision 17103)
@@ -119,4 +119,8 @@
         }
         stringBuilder.Append(")");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"ABS({FormatRecursively(node.GetSubtree(0))})");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / SQRT(1 + POWER({FormatRecursively(node.GetSubtree(1))}, 2))");
       } else if (symbol is Average) {
         stringBuilder.Append("(1/(");
@@ -137,4 +141,9 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
+      } else if (symbol is Cube) {
+        stringBuilder.Append($"POWER({FormatRecursively(node.GetSubtree(0))}, 3)");
+      } else if (symbol is CubeRoot) {
+        var arg_expr = FormatRecursively(node.GetSubtree(0));
+        stringBuilder.Append($"IF({arg_expr} < 0, -POWER(-{arg_expr}, 1/3), POWER({arg_expr}, 1/3))");
       } else if (symbol is Division) {
         if (node.SubtreeCount == 1) {
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 17103)
@@ -117,4 +117,8 @@
           strBuilder.Append(@" \cfrac{ ");
         }
+      } else if (node.Symbol is Absolute) {
+        strBuilder.Append(@"\operatorname{abs} \left( ");
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@" \frac { ");
       } else if (node.Symbol is Average) {
         // skip output of (1/1) if only one subtree
@@ -131,4 +135,8 @@
       } else if (node.Symbol is SquareRoot) {
         strBuilder.Append(@"\sqrt{");
+      } else if (node.Symbol is Cube) {
+        strBuilder.Append(@"\left(");
+      } else if (node.Symbol is CubeRoot) {
+        strBuilder.Append(@"\operatorname{cbrt}\left(");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@"\sin \left( ");
@@ -289,4 +297,8 @@
         else
           strBuilder.Append(@" }{ \cfrac{ ");
+      } else if (node.Symbol is Absolute) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@"}{\sqrt{1 + \left( ");
       } else if (node.Symbol is Average) {
         strBuilder.Append(@" + ");
@@ -298,4 +310,8 @@
         throw new InvalidOperationException();
       } else if (node.Symbol is SquareRoot) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is Cube) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is CubeRoot) {
         throw new InvalidOperationException();
       } else if (node.Symbol is Sine) {
@@ -387,4 +403,8 @@
         for (int i = 2; i < node.SubtreeCount; i++)
           strBuilder.Append(" } ");
+      } else if (node.Symbol is Absolute) {
+        strBuilder.Append(@" \right)");
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@" \right)^2}}");
       } else if (node.Symbol is Average) {
         strBuilder.Append(@" \right) ");
@@ -397,4 +417,8 @@
       } else if (node.Symbol is SquareRoot) {
         strBuilder.Append(@"}");
+      } else if (node.Symbol is Cube) {
+        strBuilder.Append(@"\right)^3");
+      } else if (node.Symbol is CubeRoot) {
+        strBuilder.Append(@"\right)");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@" \right) ");
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 17103)
@@ -126,4 +126,8 @@
         }
         stringBuilder.Append(")");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"abs({FormatRecursively(node.GetSubtree(0))})");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / sqrt(1 + ({FormatRecursively(node.GetSubtree(1))}).^2)");
       } else if (symbol is And) {
         stringBuilder.Append("((");
@@ -179,4 +183,12 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
+      } else if (symbol is Cube) {
+        stringBuilder.Append("(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(").^3");
+      } else if (symbol is CubeRoot) {
+        stringBuilder.Append("NTHROOT(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(", 3)");
       } else if (symbol is GreaterThan) {
         stringBuilder.Append("((");
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 17103)
@@ -56,4 +56,12 @@
         if (node.Symbol is Addition) {
           FormatFunction(node, "Plus", strBuilder);
+        } else if (node.Symbol is Absolute) {
+          FormatFunction(node, "Abs", strBuilder);
+        } else if (node.Symbol is AnalyticQuotient) {
+          strBuilder.Append("[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append("]/Sqrt[ 1 + Power[");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append(", 2]]");
         } else if (node.Symbol is Average) {
           FormatAverage(node, strBuilder);
@@ -104,4 +112,10 @@
         } else if (node.Symbol is SquareRoot) {
           FormatFunction(node, "Sqrt", strBuilder);
+        } else if (node.Symbol is Cube) {
+          FormatPower(node, strBuilder, "3");
+        } else if (node.Symbol is CubeRoot) {
+          strBuilder.Append("CubeRoot[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append("]");
         } else if (node.Symbol is Power) {
           FormatFunction(node, "Power", strBuilder);
@@ -205,7 +219,11 @@
 
     private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      FormatPower(node, strBuilder, "2");
+    }
+
+    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
       strBuilder.Append("Power[");
       FormatRecursively(node.GetSubtree(0), strBuilder);
-      strBuilder.Append(", 2]");
+      strBuilder.Append($", {exponent}]");
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs	(revision 17103)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Globalization;
 using System.Text;
@@ -69,4 +70,8 @@
         }
         stringBuilder.Append(") ifTrue:[1] ifFalse:[-1]");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) abs");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / (1 + ({FormatPower(node.GetSubtree(1), "2")})) sqrt");
       } else if (symbol is Average) {
         stringBuilder.Append("(1/");
@@ -84,4 +89,9 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(" cos");
+      } else if (symbol is Cube) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "3"));
+      } else if (symbol is CubeRoot) {
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(" cbrt");
       } else if (symbol is Division) {
         if (node.SubtreeCount == 1) {
@@ -146,4 +156,8 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(" sin");
+      } else if (symbol is Square) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "2"));
+      } else if (symbol is SquareRoot) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "(1/2)"));
       } else if (symbol is Subtraction) {
         if (node.SubtreeCount == 1) {
@@ -184,4 +198,8 @@
     }
 
+    private string FormatPower(ISymbolicExpressionTreeNode node, string exponent) {
+      return $"(({FormatRecursively(node)}) log * {exponent}) exp ";
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SymbolicDataAnalysisExpressionSmalltalkFormatter(this, cloner);
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs	(revision 17103)
@@ -101,5 +101,5 @@
     public static void CubeRoot(double[] a, double[] b) {
       for (int i = 0; i < BATCHSIZE; ++i)
-        a[i] = Math.Pow(b[i], 1d / 3d);
+        a[i] = b[i] < 0 ? -Math.Pow(-b[i], 1d / 3d) : Math.Pow(b[i], 1d / 3d);
     }
 
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 17103)
@@ -247,5 +247,7 @@
         case OpCodes.CubeRoot: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
-            return Expression.Power(arg, Expression.Constant(1.0 / 3.0));
+            return Expression.Condition(Expression.LessThan(arg, Expression.Constant(0.0)),
+              Expression.Negate(Expression.Power(Expression.Negate(arg), Expression.Constant(1.0 / 3.0))),
+              Expression.Power(arg, Expression.Constant(1.0 / 3.0)));
           }
         case OpCodes.Root: {
@@ -514,6 +516,6 @@
             var x1 = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var x2 = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
-            return Expression.Divide(x1, 
-              Expression.Call(Sqrt, 
+            return Expression.Divide(x1,
+              Expression.Call(Sqrt,
               Expression.Add(
                 Expression.Constant(1.0),
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 17103)
@@ -336,6 +336,20 @@
         case OpCodes.CubeRoot: {
             CompileInstructions(il, state, ds);
+            var c1 = il.DefineLabel();
+            var end = il.DefineLabel();
+
+            il.Emit(System.Reflection.Emit.OpCodes.Dup); // x
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0);
+            il.Emit(System.Reflection.Emit.OpCodes.Clt); // x < 0?
+            il.Emit(System.Reflection.Emit.OpCodes.Brfalse, c1);
+            il.Emit(System.Reflection.Emit.OpCodes.Neg); // x = -x
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
             il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            il.Emit(System.Reflection.Emit.OpCodes.Neg); // -Math.Pow(-x, 1/3)
+            il.Emit(System.Reflection.Emit.OpCodes.Br, end);
+            il.MarkLabel(c1);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            il.MarkLabel(end);
             return;
           }
@@ -422,5 +436,5 @@
             il.Emit(System.Reflection.Emit.OpCodes.Mul); // x2*x2
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
-            il.Emit(System.Reflection.Emit.OpCodes.Mul); // 1+x2*x2
+            il.Emit(System.Reflection.Emit.OpCodes.Add); // 1+x2*x2
             il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
             il.Emit(System.Reflection.Emit.OpCodes.Div);
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 17103)
@@ -232,5 +232,6 @@
           }
         case OpCodes.CubeRoot: {
-            return Math.Pow(Evaluate(dataset, ref row, state), 1.0 / 3.0);
+            var arg = Evaluate(dataset, ref row, state);
+            return arg < 0 ? -Math.Pow(-arg, 1.0 / 3.0) : Math.Pow(arg, 1.0 / 3.0);
           }
         case OpCodes.Root: {
Index: stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs
===================================================================
--- stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 17102)
+++ stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 17103)
@@ -245,5 +245,6 @@
           instr.value = Math.Sqrt(code[instr.childIndex].value);
         } else if (instr.opCode == OpCodes.CubeRoot) {
-          instr.value = Math.Pow(code[instr.childIndex].value, 1.0 / 3.0);
+          var arg = code[instr.childIndex].value;
+          instr.value = arg < 0 ? -Math.Pow(-arg, 1.0 / 3.0) : Math.Pow(arg, 1.0 / 3.0);
         } else if (instr.opCode == OpCodes.Root) {
           double x = code[instr.childIndex].value;
