
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 13 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a}
\end{array}
(FPCore (a b c)
:precision binary64
(fma
-0.5
(/ c b)
(fma
-0.5625
(/ (pow c 3.0) (/ (pow b 5.0) (* a a)))
(fma
-0.375
(/ a (/ (/ (pow b 3.0) c) c))
(* (/ (pow (* c a) 4.0) (* a (pow b 7.0))) -1.0546875)))))
double code(double a, double b, double c) {
return fma(-0.5, (c / b), fma(-0.5625, (pow(c, 3.0) / (pow(b, 5.0) / (a * a))), fma(-0.375, (a / ((pow(b, 3.0) / c) / c)), ((pow((c * a), 4.0) / (a * pow(b, 7.0))) * -1.0546875))));
}
function code(a, b, c) return fma(-0.5, Float64(c / b), fma(-0.5625, Float64((c ^ 3.0) / Float64((b ^ 5.0) / Float64(a * a))), fma(-0.375, Float64(a / Float64(Float64((b ^ 3.0) / c) / c)), Float64(Float64((Float64(c * a) ^ 4.0) / Float64(a * (b ^ 7.0))) * -1.0546875)))) end
code[a_, b_, c_] := N[(-0.5 * N[(c / b), $MachinePrecision] + N[(-0.5625 * N[(N[Power[c, 3.0], $MachinePrecision] / N[(N[Power[b, 5.0], $MachinePrecision] / N[(a * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.375 * N[(a / N[(N[(N[Power[b, 3.0], $MachinePrecision] / c), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] + N[(N[(N[Power[N[(c * a), $MachinePrecision], 4.0], $MachinePrecision] / N[(a * N[Power[b, 7.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * -1.0546875), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(-0.5, \frac{c}{b}, \mathsf{fma}\left(-0.5625, \frac{{c}^{3}}{\frac{{b}^{5}}{a \cdot a}}, \mathsf{fma}\left(-0.375, \frac{a}{\frac{\frac{{b}^{3}}{c}}{c}}, \frac{{\left(c \cdot a\right)}^{4}}{a \cdot {b}^{7}} \cdot -1.0546875\right)\right)\right)
\end{array}
Initial program 56.1%
sqr-neg56.1%
sqr-neg56.1%
associate-*l*56.1%
Simplified56.1%
associate-*r*56.1%
flip3--55.7%
pow255.7%
pow-pow55.7%
metadata-eval55.7%
associate-*r*55.7%
*-commutative55.7%
unpow-prod-down55.7%
metadata-eval55.7%
pow255.7%
pow255.7%
pow-prod-up55.9%
metadata-eval55.9%
associate-*r*55.9%
associate-*r*55.9%
associate-*r*55.9%
Applied egg-rr55.9%
Taylor expanded in b around inf 91.6%
Simplified91.6%
Taylor expanded in b around -inf 91.6%
fma-def91.6%
*-commutative91.6%
associate-/l*91.6%
unpow291.6%
fma-def91.6%
associate-/l*91.6%
unpow291.6%
associate-/r*91.6%
associate-*r/91.6%
Simplified91.6%
frac-times91.6%
div-inv91.6%
metadata-eval91.6%
Applied egg-rr91.6%
*-commutative91.6%
associate-*r*91.6%
*-commutative91.6%
times-frac91.6%
metadata-eval91.6%
Simplified91.6%
Final simplification91.6%
(FPCore (a b c) :precision binary64 (+ (fma -0.5625 (/ (* a a) (/ (pow b 5.0) (pow c 3.0))) (fma -0.5 (/ c b) (* -0.375 (/ (* a (* c c)) (pow b 3.0))))) (* -0.5 (/ (/ (* (pow (* c a) 4.0) 6.328125) a) (* 3.0 (pow b 7.0))))))
double code(double a, double b, double c) {
return fma(-0.5625, ((a * a) / (pow(b, 5.0) / pow(c, 3.0))), fma(-0.5, (c / b), (-0.375 * ((a * (c * c)) / pow(b, 3.0))))) + (-0.5 * (((pow((c * a), 4.0) * 6.328125) / a) / (3.0 * pow(b, 7.0))));
}
function code(a, b, c) return Float64(fma(-0.5625, Float64(Float64(a * a) / Float64((b ^ 5.0) / (c ^ 3.0))), fma(-0.5, Float64(c / b), Float64(-0.375 * Float64(Float64(a * Float64(c * c)) / (b ^ 3.0))))) + Float64(-0.5 * Float64(Float64(Float64((Float64(c * a) ^ 4.0) * 6.328125) / a) / Float64(3.0 * (b ^ 7.0))))) end
code[a_, b_, c_] := N[(N[(-0.5625 * N[(N[(a * a), $MachinePrecision] / N[(N[Power[b, 5.0], $MachinePrecision] / N[Power[c, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision] + N[(-0.375 * N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(N[(N[(N[Power[N[(c * a), $MachinePrecision], 4.0], $MachinePrecision] * 6.328125), $MachinePrecision] / a), $MachinePrecision] / N[(3.0 * N[Power[b, 7.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(-0.5625, \frac{a \cdot a}{\frac{{b}^{5}}{{c}^{3}}}, \mathsf{fma}\left(-0.5, \frac{c}{b}, -0.375 \cdot \frac{a \cdot \left(c \cdot c\right)}{{b}^{3}}\right)\right) + -0.5 \cdot \frac{\frac{{\left(c \cdot a\right)}^{4} \cdot 6.328125}{a}}{3 \cdot {b}^{7}}
\end{array}
Initial program 56.1%
neg-sub056.1%
sqr-neg56.1%
associate-+l-56.1%
sub0-neg56.1%
neg-mul-156.1%
Simplified56.2%
div-inv56.2%
metadata-eval56.2%
*-commutative56.2%
add-sqr-sqrt56.2%
pow256.2%
Applied egg-rr56.2%
Taylor expanded in b around inf 90.8%
Simplified91.5%
Final simplification91.5%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (pow (* (/ c b) -1.5) 2.0)))
(fma
-0.16666666666666666
(+
(/ a (/ b t_0))
(/
(* a a)
(/ b (fma 1.5 (* (/ c b) (/ t_0 b)) (* (/ -3.0 b) (/ (* c 0.0) b))))))
(* -0.5 (/ c b)))))
double code(double a, double b, double c) {
double t_0 = pow(((c / b) * -1.5), 2.0);
return fma(-0.16666666666666666, ((a / (b / t_0)) + ((a * a) / (b / fma(1.5, ((c / b) * (t_0 / b)), ((-3.0 / b) * ((c * 0.0) / b)))))), (-0.5 * (c / b)));
}
function code(a, b, c) t_0 = Float64(Float64(c / b) * -1.5) ^ 2.0 return fma(-0.16666666666666666, Float64(Float64(a / Float64(b / t_0)) + Float64(Float64(a * a) / Float64(b / fma(1.5, Float64(Float64(c / b) * Float64(t_0 / b)), Float64(Float64(-3.0 / b) * Float64(Float64(c * 0.0) / b)))))), Float64(-0.5 * Float64(c / b))) end
code[a_, b_, c_] := Block[{t$95$0 = N[Power[N[(N[(c / b), $MachinePrecision] * -1.5), $MachinePrecision], 2.0], $MachinePrecision]}, N[(-0.16666666666666666 * N[(N[(a / N[(b / t$95$0), $MachinePrecision]), $MachinePrecision] + N[(N[(a * a), $MachinePrecision] / N[(b / N[(1.5 * N[(N[(c / b), $MachinePrecision] * N[(t$95$0 / b), $MachinePrecision]), $MachinePrecision] + N[(N[(-3.0 / b), $MachinePrecision] * N[(N[(c * 0.0), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\frac{c}{b} \cdot -1.5\right)}^{2}\\
\mathsf{fma}\left(-0.16666666666666666, \frac{a}{\frac{b}{t_0}} + \frac{a \cdot a}{\frac{b}{\mathsf{fma}\left(1.5, \frac{c}{b} \cdot \frac{t_0}{b}, \frac{-3}{b} \cdot \frac{c \cdot 0}{b}\right)}}, -0.5 \cdot \frac{c}{b}\right)
\end{array}
\end{array}
Initial program 56.1%
sqr-neg56.1%
sqr-neg56.1%
associate-*l*56.1%
Simplified56.1%
associate-*r*56.1%
flip3--55.7%
pow255.7%
pow-pow55.7%
metadata-eval55.7%
associate-*r*55.7%
*-commutative55.7%
unpow-prod-down55.7%
metadata-eval55.7%
pow255.7%
pow255.7%
pow-prod-up55.9%
metadata-eval55.9%
associate-*r*55.9%
associate-*r*55.9%
associate-*r*55.9%
Applied egg-rr55.9%
Taylor expanded in a around 0 88.9%
Simplified88.9%
Final simplification88.9%
(FPCore (a b c)
:precision binary64
(/
(fma
-0.5
(+
(/ (* c c) (/ b (pow (/ (* a -1.5) b) 2.0)))
(* (* a (/ 1.5 (/ (* b b) (pow (* -1.5 (/ a b)) 2.0)))) (/ (pow c 3.0) b)))
(* -1.5 (/ a (/ b c))))
(* 3.0 a)))
double code(double a, double b, double c) {
return fma(-0.5, (((c * c) / (b / pow(((a * -1.5) / b), 2.0))) + ((a * (1.5 / ((b * b) / pow((-1.5 * (a / b)), 2.0)))) * (pow(c, 3.0) / b))), (-1.5 * (a / (b / c)))) / (3.0 * a);
}
function code(a, b, c) return Float64(fma(-0.5, Float64(Float64(Float64(c * c) / Float64(b / (Float64(Float64(a * -1.5) / b) ^ 2.0))) + Float64(Float64(a * Float64(1.5 / Float64(Float64(b * b) / (Float64(-1.5 * Float64(a / b)) ^ 2.0)))) * Float64((c ^ 3.0) / b))), Float64(-1.5 * Float64(a / Float64(b / c)))) / Float64(3.0 * a)) end
code[a_, b_, c_] := N[(N[(-0.5 * N[(N[(N[(c * c), $MachinePrecision] / N[(b / N[Power[N[(N[(a * -1.5), $MachinePrecision] / b), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(a * N[(1.5 / N[(N[(b * b), $MachinePrecision] / N[Power[N[(-1.5 * N[(a / b), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[Power[c, 3.0], $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.5 * N[(a / N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\mathsf{fma}\left(-0.5, \frac{c \cdot c}{\frac{b}{{\left(\frac{a \cdot -1.5}{b}\right)}^{2}}} + \left(a \cdot \frac{1.5}{\frac{b \cdot b}{{\left(-1.5 \cdot \frac{a}{b}\right)}^{2}}}\right) \cdot \frac{{c}^{3}}{b}, -1.5 \cdot \frac{a}{\frac{b}{c}}\right)}{3 \cdot a}
\end{array}
Initial program 56.1%
sqr-neg56.1%
sqr-neg56.1%
associate-*l*56.1%
Simplified56.1%
associate-*r*56.1%
flip3--55.7%
pow255.7%
pow-pow55.7%
metadata-eval55.7%
associate-*r*55.7%
*-commutative55.7%
unpow-prod-down55.7%
metadata-eval55.7%
pow255.7%
pow255.7%
pow-prod-up55.9%
metadata-eval55.9%
associate-*r*55.9%
associate-*r*55.9%
associate-*r*55.9%
Applied egg-rr55.9%
Taylor expanded in c around 0 88.4%
Simplified88.5%
div-inv88.5%
div088.5%
associate-*l/88.5%
associate-/r/88.5%
*-commutative88.5%
+-rgt-identity88.5%
*-commutative88.5%
Applied egg-rr88.5%
associate-*r/88.5%
*-rgt-identity88.5%
associate-/r/88.5%
*-commutative88.5%
Simplified88.5%
Final simplification88.5%
(FPCore (a b c) :precision binary64 (if (<= b 5.2) (/ (- (sqrt (fma b b (* c (* a -3.0)))) b) (pow (sqrt (* 3.0 a)) 2.0)) (fma -0.375 (/ a (/ (pow b 3.0) (* c c))) (* -0.5 (/ c b)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 5.2) {
tmp = (sqrt(fma(b, b, (c * (a * -3.0)))) - b) / pow(sqrt((3.0 * a)), 2.0);
} else {
tmp = fma(-0.375, (a / (pow(b, 3.0) / (c * c))), (-0.5 * (c / b)));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 5.2) tmp = Float64(Float64(sqrt(fma(b, b, Float64(c * Float64(a * -3.0)))) - b) / (sqrt(Float64(3.0 * a)) ^ 2.0)); else tmp = fma(-0.375, Float64(a / Float64((b ^ 3.0) / Float64(c * c))), Float64(-0.5 * Float64(c / b))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 5.2], N[(N[(N[Sqrt[N[(b * b + N[(c * N[(a * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[Power[N[Sqrt[N[(3.0 * a), $MachinePrecision]], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(-0.375 * N[(a / N[(N[Power[b, 3.0], $MachinePrecision] / N[(c * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 5.2:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, c \cdot \left(a \cdot -3\right)\right)} - b}{{\left(\sqrt{3 \cdot a}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.375, \frac{a}{\frac{{b}^{3}}{c \cdot c}}, -0.5 \cdot \frac{c}{b}\right)\\
\end{array}
\end{array}
if b < 5.20000000000000018Initial program 79.2%
neg-sub079.2%
sqr-neg79.2%
associate-+l-79.2%
sub0-neg79.2%
neg-mul-179.2%
Simplified79.3%
div-inv79.3%
metadata-eval79.3%
*-commutative79.3%
add-sqr-sqrt79.3%
pow279.3%
Applied egg-rr79.3%
Taylor expanded in a around 0 79.4%
*-commutative79.4%
associate-*r*79.3%
*-commutative79.3%
associate-*l*79.4%
Simplified79.4%
if 5.20000000000000018 < b Initial program 50.5%
sqr-neg50.5%
sqr-neg50.5%
associate-*l*50.5%
Simplified50.5%
Taylor expanded in b around inf 86.7%
+-commutative86.7%
fma-def86.7%
associate-/l*86.7%
unpow286.7%
Simplified86.7%
Final simplification85.2%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* 3.0 a)))) b) (* 3.0 a)) -3.92e-7) (* (/ (- (sqrt (fma b b (* a (* c -3.0)))) b) a) 0.3333333333333333) (* -0.5 (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) {
tmp = ((sqrt(fma(b, b, (a * (c * -3.0)))) - b) / a) * 0.3333333333333333;
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(3.0 * a)))) - b) / Float64(3.0 * a)) <= -3.92e-7) tmp = Float64(Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(c * -3.0)))) - b) / a) * 0.3333333333333333); else tmp = Float64(-0.5 * Float64(c / b)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(3.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -3.92e-7], N[(N[(N[(N[Sqrt[N[(b * b + N[(a * N[(c * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / a), $MachinePrecision] * 0.3333333333333333), $MachinePrecision], N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(3 \cdot a\right)} - b}{3 \cdot a} \leq -3.92 \cdot 10^{-7}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(c \cdot -3\right)\right)} - b}{a} \cdot 0.3333333333333333\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \frac{c}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -3.9200000000000002e-7Initial program 71.6%
neg-sub071.6%
sqr-neg71.6%
associate-+l-71.6%
sub0-neg71.6%
neg-mul-171.6%
Simplified71.7%
div-inv71.7%
metadata-eval71.7%
*-commutative71.7%
add-sqr-sqrt71.7%
pow271.7%
Applied egg-rr71.7%
unpow271.7%
add-sqr-sqrt71.7%
add-cbrt-cube71.7%
*-commutative71.7%
*-commutative71.7%
*-commutative71.7%
Applied egg-rr71.7%
swap-sqr71.7%
metadata-eval71.7%
associate-*r*71.7%
Simplified71.7%
div-sub70.7%
associate-*l*70.2%
associate-*l*70.6%
Applied egg-rr70.6%
div-sub71.7%
associate-*r*71.7%
associate-*r*71.7%
metadata-eval71.7%
swap-sqr71.7%
unpow371.7%
rem-cbrt-cube71.7%
*-lft-identity71.7%
*-commutative71.7%
times-frac71.7%
metadata-eval71.7%
Simplified71.7%
if -3.9200000000000002e-7 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 34.2%
sqr-neg34.2%
sqr-neg34.2%
associate-*l*34.2%
Simplified34.2%
Taylor expanded in b around inf 81.6%
Final simplification75.8%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* 3.0 a)))) b) (* 3.0 a)) -3.92e-7) (/ (- (sqrt (fma b b (* a (* c -3.0)))) b) (/ a 0.3333333333333333)) (* -0.5 (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) {
tmp = (sqrt(fma(b, b, (a * (c * -3.0)))) - b) / (a / 0.3333333333333333);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(3.0 * a)))) - b) / Float64(3.0 * a)) <= -3.92e-7) tmp = Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(c * -3.0)))) - b) / Float64(a / 0.3333333333333333)); else tmp = Float64(-0.5 * Float64(c / b)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(3.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -3.92e-7], N[(N[(N[Sqrt[N[(b * b + N[(a * N[(c * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(3 \cdot a\right)} - b}{3 \cdot a} \leq -3.92 \cdot 10^{-7}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(c \cdot -3\right)\right)} - b}{\frac{a}{0.3333333333333333}}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \frac{c}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -3.9200000000000002e-7Initial program 71.6%
neg-sub071.6%
sqr-neg71.6%
associate-+l-71.6%
sub0-neg71.6%
neg-mul-171.6%
Simplified71.7%
if -3.9200000000000002e-7 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 34.2%
sqr-neg34.2%
sqr-neg34.2%
associate-*l*34.2%
Simplified34.2%
Taylor expanded in b around inf 81.6%
Final simplification75.8%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* 3.0 a)))) b) (* 3.0 a)) -3.92e-7) (/ (/ (- (sqrt (fma b b (* a (* c -3.0)))) b) a) 3.0) (* -0.5 (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) {
tmp = ((sqrt(fma(b, b, (a * (c * -3.0)))) - b) / a) / 3.0;
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(3.0 * a)))) - b) / Float64(3.0 * a)) <= -3.92e-7) tmp = Float64(Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(c * -3.0)))) - b) / a) / 3.0); else tmp = Float64(-0.5 * Float64(c / b)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(3.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -3.92e-7], N[(N[(N[(N[Sqrt[N[(b * b + N[(a * N[(c * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision], N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(3 \cdot a\right)} - b}{3 \cdot a} \leq -3.92 \cdot 10^{-7}:\\
\;\;\;\;\frac{\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(c \cdot -3\right)\right)} - b}{a}}{3}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \frac{c}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -3.9200000000000002e-7Initial program 71.6%
neg-sub071.6%
sqr-neg71.6%
associate-+l-71.6%
sub0-neg71.6%
neg-mul-171.6%
Simplified71.7%
div-inv71.7%
metadata-eval71.7%
*-commutative71.7%
add-sqr-sqrt71.7%
pow271.7%
Applied egg-rr71.7%
add-log-exp67.2%
unpow267.2%
add-sqr-sqrt67.2%
*-commutative67.2%
Applied egg-rr67.2%
add-log-exp71.7%
div-sub70.7%
Applied egg-rr70.7%
div-sub71.7%
associate-/r*71.7%
Simplified71.7%
if -3.9200000000000002e-7 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 34.2%
sqr-neg34.2%
sqr-neg34.2%
associate-*l*34.2%
Simplified34.2%
Taylor expanded in b around inf 81.6%
Final simplification75.8%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* 3.0 a)))) b) (* 3.0 a)) -3.92e-7) (/ (- (sqrt (- (* b b) (* a (* c 3.0)))) b) (* 3.0 a)) (* -0.5 (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) {
tmp = (sqrt(((b * b) - (a * (c * 3.0)))) - b) / (3.0 * a);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (((sqrt(((b * b) - (c * (3.0d0 * a)))) - b) / (3.0d0 * a)) <= (-3.92d-7)) then
tmp = (sqrt(((b * b) - (a * (c * 3.0d0)))) - b) / (3.0d0 * a)
else
tmp = (-0.5d0) * (c / b)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (((Math.sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) {
tmp = (Math.sqrt(((b * b) - (a * (c * 3.0)))) - b) / (3.0 * a);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
def code(a, b, c): tmp = 0 if ((math.sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7: tmp = (math.sqrt(((b * b) - (a * (c * 3.0)))) - b) / (3.0 * a) else: tmp = -0.5 * (c / b) return tmp
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(3.0 * a)))) - b) / Float64(3.0 * a)) <= -3.92e-7) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(a * Float64(c * 3.0)))) - b) / Float64(3.0 * a)); else tmp = Float64(-0.5 * Float64(c / b)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (((sqrt(((b * b) - (c * (3.0 * a)))) - b) / (3.0 * a)) <= -3.92e-7) tmp = (sqrt(((b * b) - (a * (c * 3.0)))) - b) / (3.0 * a); else tmp = -0.5 * (c / b); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(3.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -3.92e-7], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(a * N[(c * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(3 \cdot a\right)} - b}{3 \cdot a} \leq -3.92 \cdot 10^{-7}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - a \cdot \left(c \cdot 3\right)} - b}{3 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \frac{c}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -3.9200000000000002e-7Initial program 71.6%
Taylor expanded in a around 0 71.6%
*-commutative71.6%
associate-*l*71.6%
Simplified71.6%
if -3.9200000000000002e-7 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 34.2%
sqr-neg34.2%
sqr-neg34.2%
associate-*l*34.2%
Simplified34.2%
Taylor expanded in b around inf 81.6%
Final simplification75.8%
(FPCore (a b c) :precision binary64 (if (<= b 5.5) (/ (/ (- (sqrt (fma b b (* a (* c -3.0)))) b) a) 3.0) (fma -0.375 (/ a (/ (/ (pow b 3.0) c) c)) (/ -0.5 (/ b c)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 5.5) {
tmp = ((sqrt(fma(b, b, (a * (c * -3.0)))) - b) / a) / 3.0;
} else {
tmp = fma(-0.375, (a / ((pow(b, 3.0) / c) / c)), (-0.5 / (b / c)));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 5.5) tmp = Float64(Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(c * -3.0)))) - b) / a) / 3.0); else tmp = fma(-0.375, Float64(a / Float64(Float64((b ^ 3.0) / c) / c)), Float64(-0.5 / Float64(b / c))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 5.5], N[(N[(N[(N[Sqrt[N[(b * b + N[(a * N[(c * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision], N[(-0.375 * N[(a / N[(N[(N[Power[b, 3.0], $MachinePrecision] / c), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision] + N[(-0.5 / N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 5.5:\\
\;\;\;\;\frac{\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(c \cdot -3\right)\right)} - b}{a}}{3}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.375, \frac{a}{\frac{\frac{{b}^{3}}{c}}{c}}, \frac{-0.5}{\frac{b}{c}}\right)\\
\end{array}
\end{array}
if b < 5.5Initial program 79.2%
neg-sub079.2%
sqr-neg79.2%
associate-+l-79.2%
sub0-neg79.2%
neg-mul-179.2%
Simplified79.3%
div-inv79.3%
metadata-eval79.3%
*-commutative79.3%
add-sqr-sqrt79.3%
pow279.3%
Applied egg-rr79.3%
add-log-exp74.3%
unpow274.3%
add-sqr-sqrt74.3%
*-commutative74.3%
Applied egg-rr74.3%
add-log-exp79.3%
div-sub78.0%
Applied egg-rr78.0%
div-sub79.3%
associate-/r*79.4%
Simplified79.4%
if 5.5 < b Initial program 50.5%
neg-sub050.5%
sqr-neg50.5%
associate-+l-50.5%
sub0-neg50.5%
neg-mul-150.5%
Simplified50.6%
div-inv50.6%
metadata-eval50.6%
*-commutative50.6%
add-sqr-sqrt50.6%
pow250.6%
Applied egg-rr50.6%
unpow250.6%
add-sqr-sqrt50.6%
add-cbrt-cube50.6%
*-commutative50.6%
*-commutative50.6%
*-commutative50.6%
Applied egg-rr50.6%
swap-sqr50.6%
metadata-eval50.6%
associate-*r*50.6%
Simplified50.6%
Taylor expanded in b around inf 86.7%
+-commutative86.7%
fma-def86.7%
associate-/l*86.7%
unpow286.7%
associate-/r*86.7%
associate-*r/86.7%
associate-/l*86.5%
Simplified86.5%
Final simplification85.1%
(FPCore (a b c) :precision binary64 (if (<= b 5.5) (/ (/ (- (sqrt (fma b b (* a (* c -3.0)))) b) a) 3.0) (fma -0.375 (/ a (/ (pow b 3.0) (* c c))) (* -0.5 (/ c b)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 5.5) {
tmp = ((sqrt(fma(b, b, (a * (c * -3.0)))) - b) / a) / 3.0;
} else {
tmp = fma(-0.375, (a / (pow(b, 3.0) / (c * c))), (-0.5 * (c / b)));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 5.5) tmp = Float64(Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(c * -3.0)))) - b) / a) / 3.0); else tmp = fma(-0.375, Float64(a / Float64((b ^ 3.0) / Float64(c * c))), Float64(-0.5 * Float64(c / b))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 5.5], N[(N[(N[(N[Sqrt[N[(b * b + N[(a * N[(c * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision], N[(-0.375 * N[(a / N[(N[Power[b, 3.0], $MachinePrecision] / N[(c * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 5.5:\\
\;\;\;\;\frac{\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(c \cdot -3\right)\right)} - b}{a}}{3}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.375, \frac{a}{\frac{{b}^{3}}{c \cdot c}}, -0.5 \cdot \frac{c}{b}\right)\\
\end{array}
\end{array}
if b < 5.5Initial program 79.2%
neg-sub079.2%
sqr-neg79.2%
associate-+l-79.2%
sub0-neg79.2%
neg-mul-179.2%
Simplified79.3%
div-inv79.3%
metadata-eval79.3%
*-commutative79.3%
add-sqr-sqrt79.3%
pow279.3%
Applied egg-rr79.3%
add-log-exp74.3%
unpow274.3%
add-sqr-sqrt74.3%
*-commutative74.3%
Applied egg-rr74.3%
add-log-exp79.3%
div-sub78.0%
Applied egg-rr78.0%
div-sub79.3%
associate-/r*79.4%
Simplified79.4%
if 5.5 < b Initial program 50.5%
sqr-neg50.5%
sqr-neg50.5%
associate-*l*50.5%
Simplified50.5%
Taylor expanded in b around inf 86.7%
+-commutative86.7%
fma-def86.7%
associate-/l*86.7%
unpow286.7%
Simplified86.7%
Final simplification85.2%
(FPCore (a b c) :precision binary64 (if (<= b 850.8) (/ (- (sqrt (- (* b b) (* 3.0 (* c a)))) b) (* 3.0 a)) (* -0.5 (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (b <= 850.8) {
tmp = (sqrt(((b * b) - (3.0 * (c * a)))) - b) / (3.0 * a);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= 850.8d0) then
tmp = (sqrt(((b * b) - (3.0d0 * (c * a)))) - b) / (3.0d0 * a)
else
tmp = (-0.5d0) * (c / b)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 850.8) {
tmp = (Math.sqrt(((b * b) - (3.0 * (c * a)))) - b) / (3.0 * a);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 850.8: tmp = (math.sqrt(((b * b) - (3.0 * (c * a)))) - b) / (3.0 * a) else: tmp = -0.5 * (c / b) return tmp
function code(a, b, c) tmp = 0.0 if (b <= 850.8) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(3.0 * Float64(c * a)))) - b) / Float64(3.0 * a)); else tmp = Float64(-0.5 * Float64(c / b)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 850.8) tmp = (sqrt(((b * b) - (3.0 * (c * a)))) - b) / (3.0 * a); else tmp = -0.5 * (c / b); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 850.8], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(3.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 850.8:\\
\;\;\;\;\frac{\sqrt{b \cdot b - 3 \cdot \left(c \cdot a\right)} - b}{3 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;-0.5 \cdot \frac{c}{b}\\
\end{array}
\end{array}
if b < 850.79999999999995Initial program 73.3%
sqr-neg73.3%
sqr-neg73.3%
associate-*l*73.3%
Simplified73.3%
if 850.79999999999995 < b Initial program 44.7%
sqr-neg44.7%
sqr-neg44.7%
associate-*l*44.7%
Simplified44.7%
Taylor expanded in b around inf 73.5%
Final simplification73.4%
(FPCore (a b c) :precision binary64 (* -0.5 (/ c b)))
double code(double a, double b, double c) {
return -0.5 * (c / b);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (-0.5d0) * (c / b)
end function
public static double code(double a, double b, double c) {
return -0.5 * (c / b);
}
def code(a, b, c): return -0.5 * (c / b)
function code(a, b, c) return Float64(-0.5 * Float64(c / b)) end
function tmp = code(a, b, c) tmp = -0.5 * (c / b); end
code[a_, b_, c_] := N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
-0.5 \cdot \frac{c}{b}
\end{array}
Initial program 56.1%
sqr-neg56.1%
sqr-neg56.1%
associate-*l*56.1%
Simplified56.1%
Taylor expanded in b around inf 64.1%
Final simplification64.1%
herbie shell --seed 2023277
(FPCore (a b c)
:name "Cubic critical, narrow range"
:precision binary64
:pre (and (and (and (< 1.0536712127723509e-8 a) (< a 94906265.62425156)) (and (< 1.0536712127723509e-8 b) (< b 94906265.62425156))) (and (< 1.0536712127723509e-8 c) (< c 94906265.62425156)))
(/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))