2-ancestry mixing, positive discriminant

Percentage Accurate: 43.4% → 76.3%

Time: 4.8s

Alternatives: 5

Speedup: 1.4×

Specification

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{2 \cdot a}\\ t_1 := \sqrt{g \cdot g - h \cdot h}\\ \sqrt[3]{t\_0 \cdot \left(\left(-g\right) + t\_1\right)} + \sqrt[3]{t\_0 \cdot \left(\left(-g\right) - t\_1\right)} \end{array} \end{array} \]

FPCore

(FPCore (g h a)
 :precision binary64
 (let* ((t_0 (/ 1.0 (* 2.0 a))) (t_1 (sqrt (- (* g g) (* h h)))))
   (+ (cbrt (* t_0 (+ (- g) t_1))) (cbrt (* t_0 (- (- g) t_1))))))

C

double code(double g, double h, double a) {
	double t_0 = 1.0 / (2.0 * a);
	double t_1 = sqrt(((g * g) - (h * h)));
	return cbrt((t_0 * (-g + t_1))) + cbrt((t_0 * (-g - t_1)));
}

Java

public static double code(double g, double h, double a) {
	double t_0 = 1.0 / (2.0 * a);
	double t_1 = Math.sqrt(((g * g) - (h * h)));
	return Math.cbrt((t_0 * (-g + t_1))) + Math.cbrt((t_0 * (-g - t_1)));
}

Julia

function code(g, h, a)
	t_0 = Float64(1.0 / Float64(2.0 * a))
	t_1 = sqrt(Float64(Float64(g * g) - Float64(h * h)))
	return Float64(cbrt(Float64(t_0 * Float64(Float64(-g) + t_1))) + cbrt(Float64(t_0 * Float64(Float64(-g) - t_1))))
end

Wolfram

code[g_, h_, a_] := Block[{t$95$0 = N[(1.0 / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(N[(g * g), $MachinePrecision] - N[(h * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, N[(N[Power[N[(t$95$0 * N[((-g) + t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(t$95$0 * N[((-g) - t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]]]

Initial Program: 43.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{1}{2 \cdot a}\\ t_1 := \sqrt{g \cdot g - h \cdot h}\\ \sqrt[3]{t\_0 \cdot \left(\left(-g\right) + t\_1\right)} + \sqrt[3]{t\_0 \cdot \left(\left(-g\right) - t\_1\right)} \end{array} \end{array} \]

FPCore

(FPCore (g h a)
 :precision binary64
 (let* ((t_0 (/ 1.0 (* 2.0 a))) (t_1 (sqrt (- (* g g) (* h h)))))
   (+ (cbrt (* t_0 (+ (- g) t_1))) (cbrt (* t_0 (- (- g) t_1))))))

C

double code(double g, double h, double a) {
	double t_0 = 1.0 / (2.0 * a);
	double t_1 = sqrt(((g * g) - (h * h)));
	return cbrt((t_0 * (-g + t_1))) + cbrt((t_0 * (-g - t_1)));
}

Java

public static double code(double g, double h, double a) {
	double t_0 = 1.0 / (2.0 * a);
	double t_1 = Math.sqrt(((g * g) - (h * h)));
	return Math.cbrt((t_0 * (-g + t_1))) + Math.cbrt((t_0 * (-g - t_1)));
}

Julia

function code(g, h, a)
	t_0 = Float64(1.0 / Float64(2.0 * a))
	t_1 = sqrt(Float64(Float64(g * g) - Float64(h * h)))
	return Float64(cbrt(Float64(t_0 * Float64(Float64(-g) + t_1))) + cbrt(Float64(t_0 * Float64(Float64(-g) - t_1))))
end

Wolfram

code[g_, h_, a_] := Block[{t$95$0 = N[(1.0 / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(N[(g * g), $MachinePrecision] - N[(h * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, N[(N[Power[N[(t$95$0 * N[((-g) + t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(t$95$0 * N[((-g) - t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]]]

Alternative 1: 76.3% accurate, 0.3× speedup

Math

\[\begin{array}{l} g\_m = \left|g\right| \\ g\_s = \mathsf{copysign}\left(1, g\right) \\ a\_m = \left|a\right| \\ a\_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := \sqrt[3]{-0.5} \cdot \sqrt[3]{2}\\ t_1 := \sqrt{g\_m \cdot g\_m - h \cdot h}\\ t_2 := \frac{1}{2 \cdot a\_m}\\ a\_s \cdot \left(g\_s \cdot \begin{array}{l} \mathbf{if}\;\sqrt[3]{t\_2 \cdot \left(\left(-g\_m\right) + t\_1\right)} + \sqrt[3]{t\_2 \cdot \left(\left(-g\_m\right) - t\_1\right)} \leq -5 \cdot 10^{+68}:\\ \;\;\;\;g\_m \cdot \mathsf{fma}\left(\sqrt[3]{\frac{1}{a\_m \cdot {g\_m}^{2}}}, t\_0, \sqrt[3]{\frac{{h}^{2}}{a\_m \cdot {g\_m}^{4}}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{0.5}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\sqrt[3]{\frac{g\_m}{a\_m}} \cdot t\_0\\ \end{array}\right) \end{array} \end{array} \]

FPCore

g\_m = (fabs.f64 g)
g\_s = (copysign.f64 #s(literal 1 binary64) g)
a\_m = (fabs.f64 a)
a\_s = (copysign.f64 #s(literal 1 binary64) a)
(FPCore (a_s g_s g_m h a_m)
 :precision binary64
 (let* ((t_0 (* (cbrt -0.5) (cbrt 2.0)))
        (t_1 (sqrt (- (* g_m g_m) (* h h))))
        (t_2 (/ 1.0 (* 2.0 a_m))))
   (*
    a_s
    (*
     g_s
     (if (<=
          (+ (cbrt (* t_2 (+ (- g_m) t_1))) (cbrt (* t_2 (- (- g_m) t_1))))
          -5e+68)
       (*
        g_m
        (fma
         (cbrt (/ 1.0 (* a_m (pow g_m 2.0))))
         t_0
         (*
          (cbrt (/ (pow h 2.0) (* a_m (pow g_m 4.0))))
          (* (cbrt -0.5) (cbrt 0.5)))))
       (* (cbrt (/ g_m a_m)) t_0))))))

C

g\_m = fabs(g);
g\_s = copysign(1.0, g);
a\_m = fabs(a);
a\_s = copysign(1.0, a);
double code(double a_s, double g_s, double g_m, double h, double a_m) {
	double t_0 = cbrt(-0.5) * cbrt(2.0);
	double t_1 = sqrt(((g_m * g_m) - (h * h)));
	double t_2 = 1.0 / (2.0 * a_m);
	double tmp;
	if ((cbrt((t_2 * (-g_m + t_1))) + cbrt((t_2 * (-g_m - t_1)))) <= -5e+68) {
		tmp = g_m * fma(cbrt((1.0 / (a_m * pow(g_m, 2.0)))), t_0, (cbrt((pow(h, 2.0) / (a_m * pow(g_m, 4.0)))) * (cbrt(-0.5) * cbrt(0.5))));
	} else {
		tmp = cbrt((g_m / a_m)) * t_0;
	}
	return a_s * (g_s * tmp);
}

Julia

g\_m = abs(g)
g\_s = copysign(1.0, g)
a\_m = abs(a)
a\_s = copysign(1.0, a)
function code(a_s, g_s, g_m, h, a_m)
	t_0 = Float64(cbrt(-0.5) * cbrt(2.0))
	t_1 = sqrt(Float64(Float64(g_m * g_m) - Float64(h * h)))
	t_2 = Float64(1.0 / Float64(2.0 * a_m))
	tmp = 0.0
	if (Float64(cbrt(Float64(t_2 * Float64(Float64(-g_m) + t_1))) + cbrt(Float64(t_2 * Float64(Float64(-g_m) - t_1)))) <= -5e+68)
		tmp = Float64(g_m * fma(cbrt(Float64(1.0 / Float64(a_m * (g_m ^ 2.0)))), t_0, Float64(cbrt(Float64((h ^ 2.0) / Float64(a_m * (g_m ^ 4.0)))) * Float64(cbrt(-0.5) * cbrt(0.5)))));
	else
		tmp = Float64(cbrt(Float64(g_m / a_m)) * t_0);
	end
	return Float64(a_s * Float64(g_s * tmp))
end

Wolfram

g\_m = N[Abs[g], $MachinePrecision]
g\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[g]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
a\_m = N[Abs[a], $MachinePrecision]
a\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, g$95$s_, g$95$m_, h_, a$95$m_] := Block[{t$95$0 = N[(N[Power[-0.5, 1/3], $MachinePrecision] * N[Power[2.0, 1/3], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(N[(g$95$m * g$95$m), $MachinePrecision] - N[(h * h), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(1.0 / N[(2.0 * a$95$m), $MachinePrecision]), $MachinePrecision]}, N[(a$95$s * N[(g$95$s * If[LessEqual[N[(N[Power[N[(t$95$2 * N[((-g$95$m) + t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(t$95$2 * N[((-g$95$m) - t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], -5e+68], N[(g$95$m * N[(N[Power[N[(1.0 / N[(a$95$m * N[Power[g$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * t$95$0 + N[(N[Power[N[(N[Power[h, 2.0], $MachinePrecision] / N[(a$95$m * N[Power[g$95$m, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] * N[(N[Power[-0.5, 1/3], $MachinePrecision] * N[Power[0.5, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(g$95$m / a$95$m), $MachinePrecision], 1/3], $MachinePrecision] * t$95$0), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (cbrt.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) a)) (+.f64 (neg.f64 g) (sqrt.f64 (-.f64 (*.f64 g g) (*.f64 h h)))))) (cbrt.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) a)) (-.f64 (neg.f64 g) (sqrt.f64 (-.f64 (*.f64 g g) (*.f64 h h))))))) < -5.0000000000000004e68

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \color{blue}{g \cdot \left(\sqrt[3]{\frac{1}{a \cdot {g}^{2}}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right) + \sqrt[3]{\frac{{h}^{2}}{a \cdot {g}^{4}}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\frac{1}{2}}\right)\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto g \cdot \color{blue}{\left(\sqrt[3]{\frac{1}{a \cdot {g}^{2}}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right) + \sqrt[3]{\frac{{h}^{2}}{a \cdot {g}^{4}}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\frac{1}{2}}\right)\right)} \]

      2. lower-fma.f64 N/A

         \[\leadsto g \cdot \mathsf{fma}\left(\sqrt[3]{\frac{1}{a \cdot {g}^{2}}}, \color{blue}{\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}}, \sqrt[3]{\frac{{h}^{2}}{a \cdot {g}^{4}}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\frac{1}{2}}\right)\right) \]

   4. Applied rewrites 31.7%

      \[\leadsto \color{blue}{g \cdot \mathsf{fma}\left(\sqrt[3]{\frac{1}{a \cdot {g}^{2}}}, \sqrt[3]{-0.5} \cdot \sqrt[3]{2}, \sqrt[3]{\frac{{h}^{2}}{a \cdot {g}^{4}}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{0.5}\right)\right)} \]

   if -5.0000000000000004e68 < (+.f64 (cbrt.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) a)) (+.f64 (neg.f64 g) (sqrt.f64 (-.f64 (*.f64 g g) (*.f64 h h)))))) (cbrt.f64 (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal 2 binary64) a)) (-.f64 (neg.f64 g) (sqrt.f64 (-.f64 (*.f64 g g) (*.f64 h h)))))))

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \color{blue}{\left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]

      2. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\color{blue}{\sqrt[3]{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      3. lower-/.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\color{blue}{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      4. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \color{blue}{\sqrt[3]{2}}\right) \]

      5. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\color{blue}{2}}\right) \]

      6. lower-cbrt.f64 73.2

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right) \]

   4. Applied rewrites 73.2%

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 74.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} g\_m = \left|g\right| \\ g\_s = \mathsf{copysign}\left(1, g\right) \\ a\_m = \left|a\right| \\ a\_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := \frac{1}{2 \cdot a\_m}\\ a\_s \cdot \left(g\_s \cdot \begin{array}{l} \mathbf{if}\;h \leq 6.8 \cdot 10^{+133}:\\ \;\;\;\;\sqrt[3]{t\_0 \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g\_m}\right)} + \sqrt[3]{t\_0 \cdot \left(-2 \cdot g\_m\right)}\\ \mathbf{else}:\\ \;\;\;\;\sqrt[3]{\frac{g\_m}{a\_m}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)\\ \end{array}\right) \end{array} \end{array} \]

FPCore

g\_m = (fabs.f64 g)
g\_s = (copysign.f64 #s(literal 1 binary64) g)
a\_m = (fabs.f64 a)
a\_s = (copysign.f64 #s(literal 1 binary64) a)
(FPCore (a_s g_s g_m h a_m)
 :precision binary64
 (let* ((t_0 (/ 1.0 (* 2.0 a_m))))
   (*
    a_s
    (*
     g_s
     (if (<= h 6.8e+133)
       (+
        (cbrt (* t_0 (* -0.5 (/ (pow h 2.0) g_m))))
        (cbrt (* t_0 (* -2.0 g_m))))
       (* (cbrt (/ g_m a_m)) (* (cbrt -0.5) (cbrt 2.0))))))))

C

g\_m = fabs(g);
g\_s = copysign(1.0, g);
a\_m = fabs(a);
a\_s = copysign(1.0, a);
double code(double a_s, double g_s, double g_m, double h, double a_m) {
	double t_0 = 1.0 / (2.0 * a_m);
	double tmp;
	if (h <= 6.8e+133) {
		tmp = cbrt((t_0 * (-0.5 * (pow(h, 2.0) / g_m)))) + cbrt((t_0 * (-2.0 * g_m)));
	} else {
		tmp = cbrt((g_m / a_m)) * (cbrt(-0.5) * cbrt(2.0));
	}
	return a_s * (g_s * tmp);
}

Java

g\_m = Math.abs(g);
g\_s = Math.copySign(1.0, g);
a\_m = Math.abs(a);
a\_s = Math.copySign(1.0, a);
public static double code(double a_s, double g_s, double g_m, double h, double a_m) {
	double t_0 = 1.0 / (2.0 * a_m);
	double tmp;
	if (h <= 6.8e+133) {
		tmp = Math.cbrt((t_0 * (-0.5 * (Math.pow(h, 2.0) / g_m)))) + Math.cbrt((t_0 * (-2.0 * g_m)));
	} else {
		tmp = Math.cbrt((g_m / a_m)) * (Math.cbrt(-0.5) * Math.cbrt(2.0));
	}
	return a_s * (g_s * tmp);
}

Julia

g\_m = abs(g)
g\_s = copysign(1.0, g)
a\_m = abs(a)
a\_s = copysign(1.0, a)
function code(a_s, g_s, g_m, h, a_m)
	t_0 = Float64(1.0 / Float64(2.0 * a_m))
	tmp = 0.0
	if (h <= 6.8e+133)
		tmp = Float64(cbrt(Float64(t_0 * Float64(-0.5 * Float64((h ^ 2.0) / g_m)))) + cbrt(Float64(t_0 * Float64(-2.0 * g_m))));
	else
		tmp = Float64(cbrt(Float64(g_m / a_m)) * Float64(cbrt(-0.5) * cbrt(2.0)));
	end
	return Float64(a_s * Float64(g_s * tmp))
end

Wolfram

g\_m = N[Abs[g], $MachinePrecision]
g\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[g]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
a\_m = N[Abs[a], $MachinePrecision]
a\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, g$95$s_, g$95$m_, h_, a$95$m_] := Block[{t$95$0 = N[(1.0 / N[(2.0 * a$95$m), $MachinePrecision]), $MachinePrecision]}, N[(a$95$s * N[(g$95$s * If[LessEqual[h, 6.8e+133], N[(N[Power[N[(t$95$0 * N[(-0.5 * N[(N[Power[h, 2.0], $MachinePrecision] / g$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(t$95$0 * N[(-2.0 * g$95$m), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(g$95$m / a$95$m), $MachinePrecision], 1/3], $MachinePrecision] * N[(N[Power[-0.5, 1/3], $MachinePrecision] * N[Power[2.0, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if h < 6.79999999999999975e133

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(\frac{-1}{2} \cdot \frac{{h}^{2}}{g}\right)}} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\frac{-1}{2} \cdot \color{blue}{\frac{{h}^{2}}{g}}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

      2. lower-/.f64 N/A

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\frac{-1}{2} \cdot \frac{{h}^{2}}{\color{blue}{g}}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

      3. lower-pow.f64 45.7

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   4. Applied rewrites 45.7%

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(-0.5 \cdot \frac{{h}^{2}}{g}\right)}} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   5. Taylor expanded in g around inf

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\frac{-1}{2} \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(-2 \cdot g\right)}} \]
   6. Step-by-step derivation

      1. lower-*.f64 71.6

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(-2 \cdot \color{blue}{g}\right)} \]

   7. Applied rewrites 71.6%

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(-2 \cdot g\right)}} \]

   if 6.79999999999999975e133 < h

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \color{blue}{\left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]

      2. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\color{blue}{\sqrt[3]{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      3. lower-/.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\color{blue}{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      4. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \color{blue}{\sqrt[3]{2}}\right) \]

      5. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\color{blue}{2}}\right) \]

      6. lower-cbrt.f64 73.2

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right) \]

   4. Applied rewrites 73.2%

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 73.2% accurate, 1.1× speedup

Math

\[\begin{array}{l} g\_m = \left|g\right| \\ g\_s = \mathsf{copysign}\left(1, g\right) \\ a\_m = \left|a\right| \\ a\_s = \mathsf{copysign}\left(1, a\right) \\ a\_s \cdot \left(g\_s \cdot \begin{array}{l} \mathbf{if}\;h \cdot h \leq 2 \cdot 10^{+264}:\\ \;\;\;\;\sqrt[3]{\frac{0.5}{a\_m} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g\_m}\right)} + \sqrt[3]{-1 \cdot \frac{g\_m}{a\_m}}\\ \mathbf{else}:\\ \;\;\;\;\sqrt[3]{\frac{g\_m}{a\_m}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)\\ \end{array}\right) \end{array} \]

FPCore

g\_m = (fabs.f64 g)
g\_s = (copysign.f64 #s(literal 1 binary64) g)
a\_m = (fabs.f64 a)
a\_s = (copysign.f64 #s(literal 1 binary64) a)
(FPCore (a_s g_s g_m h a_m)
 :precision binary64
 (*
  a_s
  (*
   g_s
   (if (<= (* h h) 2e+264)
     (+
      (cbrt (* (/ 0.5 a_m) (* -0.5 (/ (pow h 2.0) g_m))))
      (cbrt (* -1.0 (/ g_m a_m))))
     (* (cbrt (/ g_m a_m)) (* (cbrt -0.5) (cbrt 2.0)))))))

C

g\_m = fabs(g);
g\_s = copysign(1.0, g);
a\_m = fabs(a);
a\_s = copysign(1.0, a);
double code(double a_s, double g_s, double g_m, double h, double a_m) {
	double tmp;
	if ((h * h) <= 2e+264) {
		tmp = cbrt(((0.5 / a_m) * (-0.5 * (pow(h, 2.0) / g_m)))) + cbrt((-1.0 * (g_m / a_m)));
	} else {
		tmp = cbrt((g_m / a_m)) * (cbrt(-0.5) * cbrt(2.0));
	}
	return a_s * (g_s * tmp);
}

Java

g\_m = Math.abs(g);
g\_s = Math.copySign(1.0, g);
a\_m = Math.abs(a);
a\_s = Math.copySign(1.0, a);
public static double code(double a_s, double g_s, double g_m, double h, double a_m) {
	double tmp;
	if ((h * h) <= 2e+264) {
		tmp = Math.cbrt(((0.5 / a_m) * (-0.5 * (Math.pow(h, 2.0) / g_m)))) + Math.cbrt((-1.0 * (g_m / a_m)));
	} else {
		tmp = Math.cbrt((g_m / a_m)) * (Math.cbrt(-0.5) * Math.cbrt(2.0));
	}
	return a_s * (g_s * tmp);
}

Julia

g\_m = abs(g)
g\_s = copysign(1.0, g)
a\_m = abs(a)
a\_s = copysign(1.0, a)
function code(a_s, g_s, g_m, h, a_m)
	tmp = 0.0
	if (Float64(h * h) <= 2e+264)
		tmp = Float64(cbrt(Float64(Float64(0.5 / a_m) * Float64(-0.5 * Float64((h ^ 2.0) / g_m)))) + cbrt(Float64(-1.0 * Float64(g_m / a_m))));
	else
		tmp = Float64(cbrt(Float64(g_m / a_m)) * Float64(cbrt(-0.5) * cbrt(2.0)));
	end
	return Float64(a_s * Float64(g_s * tmp))
end

Wolfram

g\_m = N[Abs[g], $MachinePrecision]
g\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[g]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
a\_m = N[Abs[a], $MachinePrecision]
a\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, g$95$s_, g$95$m_, h_, a$95$m_] := N[(a$95$s * N[(g$95$s * If[LessEqual[N[(h * h), $MachinePrecision], 2e+264], N[(N[Power[N[(N[(0.5 / a$95$m), $MachinePrecision] * N[(-0.5 * N[(N[Power[h, 2.0], $MachinePrecision] / g$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(-1.0 * N[(g$95$m / a$95$m), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(g$95$m / a$95$m), $MachinePrecision], 1/3], $MachinePrecision] * N[(N[Power[-0.5, 1/3], $MachinePrecision] * N[Power[2.0, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if (*.f64 h h) < 2.00000000000000009e264

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\color{blue}{-1 \cdot \frac{g}{a}}} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{-1 \cdot \color{blue}{\frac{g}{a}}} \]

      2. lower-/.f64 43.3

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{-1 \cdot \frac{g}{\color{blue}{a}}} \]

   4. Applied rewrites 43.3%

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\color{blue}{-1 \cdot \frac{g}{a}}} \]

   5. Taylor expanded in g around inf

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(\frac{-1}{2} \cdot \frac{{h}^{2}}{g}\right)}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]
   6. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\frac{-1}{2} \cdot \color{blue}{\frac{{h}^{2}}{g}}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

      2. lower-/.f64 N/A

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\frac{-1}{2} \cdot \frac{{h}^{2}}{\color{blue}{g}}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

      3. lift-pow.f64 71.7

         \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   7. Applied rewrites 71.7%

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \color{blue}{\left(-0.5 \cdot \frac{{h}^{2}}{g}\right)}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   8. Taylor expanded in a around 0

      \[\leadsto \sqrt[3]{\color{blue}{\frac{\frac{1}{2}}{a}} \cdot \left(\frac{-1}{2} \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]
   9. Step-by-step derivation

      1. lower-/.f64 71.7

         \[\leadsto \sqrt[3]{\frac{0.5}{\color{blue}{a}} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   10. Applied rewrites 71.7%

       \[\leadsto \sqrt[3]{\color{blue}{\frac{0.5}{a}} \cdot \left(-0.5 \cdot \frac{{h}^{2}}{g}\right)} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   if 2.00000000000000009e264 < (*.f64 h h)

   1. Initial program 43.4%

      \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

   2. Taylor expanded in g around inf

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]
   3. Step-by-step derivation

      1. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \color{blue}{\left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]

      2. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\color{blue}{\sqrt[3]{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      3. lower-/.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\color{blue}{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

      4. lower-*.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \color{blue}{\sqrt[3]{2}}\right) \]

      5. lower-cbrt.f64 N/A

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\color{blue}{2}}\right) \]

      6. lower-cbrt.f64 73.2

         \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right) \]

   4. Applied rewrites 73.2%

      \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 73.2% accurate, 1.4× speedup

Math

\[\begin{array}{l} g\_m = \left|g\right| \\ g\_s = \mathsf{copysign}\left(1, g\right) \\ a\_m = \left|a\right| \\ a\_s = \mathsf{copysign}\left(1, a\right) \\ a\_s \cdot \left(g\_s \cdot \left(\sqrt[3]{\frac{g\_m}{a\_m}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)\right)\right) \end{array} \]

FPCore

g\_m = (fabs.f64 g)
g\_s = (copysign.f64 #s(literal 1 binary64) g)
a\_m = (fabs.f64 a)
a\_s = (copysign.f64 #s(literal 1 binary64) a)
(FPCore (a_s g_s g_m h a_m)
 :precision binary64
 (* a_s (* g_s (* (cbrt (/ g_m a_m)) (* (cbrt -0.5) (cbrt 2.0))))))

C

g\_m = fabs(g);
g\_s = copysign(1.0, g);
a\_m = fabs(a);
a\_s = copysign(1.0, a);
double code(double a_s, double g_s, double g_m, double h, double a_m) {
	return a_s * (g_s * (cbrt((g_m / a_m)) * (cbrt(-0.5) * cbrt(2.0))));
}

Java

g\_m = Math.abs(g);
g\_s = Math.copySign(1.0, g);
a\_m = Math.abs(a);
a\_s = Math.copySign(1.0, a);
public static double code(double a_s, double g_s, double g_m, double h, double a_m) {
	return a_s * (g_s * (Math.cbrt((g_m / a_m)) * (Math.cbrt(-0.5) * Math.cbrt(2.0))));
}

Julia

g\_m = abs(g)
g\_s = copysign(1.0, g)
a\_m = abs(a)
a\_s = copysign(1.0, a)
function code(a_s, g_s, g_m, h, a_m)
	return Float64(a_s * Float64(g_s * Float64(cbrt(Float64(g_m / a_m)) * Float64(cbrt(-0.5) * cbrt(2.0)))))
end

Wolfram

g\_m = N[Abs[g], $MachinePrecision]
g\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[g]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
a\_m = N[Abs[a], $MachinePrecision]
a\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, g$95$s_, g$95$m_, h_, a$95$m_] := N[(a$95$s * N[(g$95$s * N[(N[Power[N[(g$95$m / a$95$m), $MachinePrecision], 1/3], $MachinePrecision] * N[(N[Power[-0.5, 1/3], $MachinePrecision] * N[Power[2.0, 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 43.4%

   \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

2. Taylor expanded in g around inf

   \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]
3. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \color{blue}{\left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{2}\right)} \]

   2. lower-cbrt.f64 N/A

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\color{blue}{\sqrt[3]{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

   3. lower-/.f64 N/A

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\color{blue}{\frac{-1}{2}}} \cdot \sqrt[3]{2}\right) \]

   4. lower-*.f64 N/A

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \color{blue}{\sqrt[3]{2}}\right) \]

   5. lower-cbrt.f64 N/A

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{\frac{-1}{2}} \cdot \sqrt[3]{\color{blue}{2}}\right) \]

   6. lower-cbrt.f64 73.2

      \[\leadsto \sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right) \]

4. Applied rewrites 73.2%

   \[\leadsto \color{blue}{\sqrt[3]{\frac{g}{a}} \cdot \left(\sqrt[3]{-0.5} \cdot \sqrt[3]{2}\right)} \]
5. Add Preprocessing

Alternative 5: 0.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} g\_m = \left|g\right| \\ g\_s = \mathsf{copysign}\left(1, g\right) \\ a\_m = \left|a\right| \\ a\_s = \mathsf{copysign}\left(1, a\right) \\ a\_s \cdot \left(g\_s \cdot \left(\sqrt[3]{0.5 \cdot \frac{h \cdot \sqrt{-1}}{a\_m}} + \sqrt[3]{-1 \cdot \frac{g\_m}{a\_m}}\right)\right) \end{array} \]

FPCore

g\_m = (fabs.f64 g)
g\_s = (copysign.f64 #s(literal 1 binary64) g)
a\_m = (fabs.f64 a)
a\_s = (copysign.f64 #s(literal 1 binary64) a)
(FPCore (a_s g_s g_m h a_m)
 :precision binary64
 (*
  a_s
  (*
   g_s
   (+ (cbrt (* 0.5 (/ (* h (sqrt -1.0)) a_m))) (cbrt (* -1.0 (/ g_m a_m)))))))

C

g\_m = fabs(g);
g\_s = copysign(1.0, g);
a\_m = fabs(a);
a\_s = copysign(1.0, a);
double code(double a_s, double g_s, double g_m, double h, double a_m) {
	return a_s * (g_s * (cbrt((0.5 * ((h * sqrt(-1.0)) / a_m))) + cbrt((-1.0 * (g_m / a_m)))));
}

Java

g\_m = Math.abs(g);
g\_s = Math.copySign(1.0, g);
a\_m = Math.abs(a);
a\_s = Math.copySign(1.0, a);
public static double code(double a_s, double g_s, double g_m, double h, double a_m) {
	return a_s * (g_s * (Math.cbrt((0.5 * ((h * Math.sqrt(-1.0)) / a_m))) + Math.cbrt((-1.0 * (g_m / a_m)))));
}

Julia

g\_m = abs(g)
g\_s = copysign(1.0, g)
a\_m = abs(a)
a\_s = copysign(1.0, a)
function code(a_s, g_s, g_m, h, a_m)
	return Float64(a_s * Float64(g_s * Float64(cbrt(Float64(0.5 * Float64(Float64(h * sqrt(-1.0)) / a_m))) + cbrt(Float64(-1.0 * Float64(g_m / a_m))))))
end

Wolfram

g\_m = N[Abs[g], $MachinePrecision]
g\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[g]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
a\_m = N[Abs[a], $MachinePrecision]
a\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, g$95$s_, g$95$m_, h_, a$95$m_] := N[(a$95$s * N[(g$95$s * N[(N[Power[N[(0.5 * N[(N[(h * N[Sqrt[-1.0], $MachinePrecision]), $MachinePrecision] / a$95$m), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] + N[Power[N[(-1.0 * N[(g$95$m / a$95$m), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 43.4%

   \[\sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) - \sqrt{g \cdot g - h \cdot h}\right)} \]

2. Taylor expanded in g around inf

   \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\color{blue}{-1 \cdot \frac{g}{a}}} \]
3. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{-1 \cdot \color{blue}{\frac{g}{a}}} \]

   2. lower-/.f64 43.3

      \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{-1 \cdot \frac{g}{\color{blue}{a}}} \]

4. Applied rewrites 43.3%

   \[\leadsto \sqrt[3]{\frac{1}{2 \cdot a} \cdot \left(\left(-g\right) + \sqrt{g \cdot g - h \cdot h}\right)} + \sqrt[3]{\color{blue}{-1 \cdot \frac{g}{a}}} \]

5. Taylor expanded in g around 0

   \[\leadsto \sqrt[3]{\color{blue}{\frac{1}{2} \cdot \frac{h \cdot \sqrt{-1}}{a}}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]
6. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \sqrt[3]{\frac{1}{2} \cdot \color{blue}{\frac{h \cdot \sqrt{-1}}{a}}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   2. lower-/.f64 N/A

      \[\leadsto \sqrt[3]{\frac{1}{2} \cdot \frac{h \cdot \sqrt{-1}}{\color{blue}{a}}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   3. lower-*.f64 N/A

      \[\leadsto \sqrt[3]{\frac{1}{2} \cdot \frac{h \cdot \sqrt{-1}}{a}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

   4. lower-sqrt.f64 0.0

      \[\leadsto \sqrt[3]{0.5 \cdot \frac{h \cdot \sqrt{-1}}{a}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]

7. Applied rewrites 0.0%

   \[\leadsto \sqrt[3]{\color{blue}{0.5 \cdot \frac{h \cdot \sqrt{-1}}{a}}} + \sqrt[3]{-1 \cdot \frac{g}{a}} \]
8. Add Preprocessing

Reproduce

herbie shell --seed 2025132 
(FPCore (g h a)
  :name "2-ancestry mixing, positive discriminant"
  :precision binary64
  (+ (cbrt (* (/ 1.0 (* 2.0 a)) (+ (- g) (sqrt (- (* g g) (* h h)))))) (cbrt (* (/ 1.0 (* 2.0 a)) (- (- g) (sqrt (- (* g g) (* h h))))))))