
(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 10 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 (/ (/ (* (* -3.0 a) c) (+ b (sqrt (fma b b (* -3.0 (* a c)))))) (* (pow (cbrt a) 2.0) (* (cbrt a) 3.0))))
double code(double a, double b, double c) {
return (((-3.0 * a) * c) / (b + sqrt(fma(b, b, (-3.0 * (a * c)))))) / (pow(cbrt(a), 2.0) * (cbrt(a) * 3.0));
}
function code(a, b, c) return Float64(Float64(Float64(Float64(-3.0 * a) * c) / Float64(b + sqrt(fma(b, b, Float64(-3.0 * Float64(a * c)))))) / Float64((cbrt(a) ^ 2.0) * Float64(cbrt(a) * 3.0))) end
code[a_, b_, c_] := N[(N[(N[(N[(-3.0 * a), $MachinePrecision] * c), $MachinePrecision] / N[(b + N[Sqrt[N[(b * b + N[(-3.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[Power[a, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Power[a, 1/3], $MachinePrecision] * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\left(-3 \cdot a\right) \cdot c}{b + \sqrt{\mathsf{fma}\left(b, b, -3 \cdot \left(a \cdot c\right)\right)}}}{{\left(\sqrt[3]{a}\right)}^{2} \cdot \left(\sqrt[3]{a} \cdot 3\right)}
\end{array}
Initial program 52.5%
neg-sub052.5%
sqr-neg52.5%
associate-+l-52.5%
sub0-neg52.5%
neg-mul-152.5%
Simplified52.7%
div-inv52.7%
add-cube-cbrt52.6%
metadata-eval52.6%
associate-*l*52.6%
pow252.6%
Applied egg-rr52.6%
add-cbrt-cube52.6%
Applied egg-rr52.6%
flip--52.6%
add-sqr-sqrt54.1%
add-cbrt-cube54.1%
associate-*r*54.1%
Applied egg-rr54.1%
Taylor expanded in b around 0 97.8%
associate-*r*97.8%
Simplified97.8%
Final simplification97.8%
(FPCore (a b c)
:precision binary64
(if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.09)
(/ (- (sqrt (fma b b (* a (* -3.0 c)))) b) (/ a 0.3333333333333333))
(+
(fma -0.5 (/ c b) (* -0.375 (* (/ a (pow b 3.0)) (* c c))))
(* -0.5625 (/ (* a a) (/ (pow b 5.0) (pow c 3.0)))))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.09) {
tmp = (sqrt(fma(b, b, (a * (-3.0 * c)))) - b) / (a / 0.3333333333333333);
} else {
tmp = fma(-0.5, (c / b), (-0.375 * ((a / pow(b, 3.0)) * (c * c)))) + (-0.5625 * ((a * a) / (pow(b, 5.0) / pow(c, 3.0))));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.09) tmp = Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(-3.0 * c)))) - b) / Float64(a / 0.3333333333333333)); else tmp = Float64(fma(-0.5, Float64(c / b), Float64(-0.375 * Float64(Float64(a / (b ^ 3.0)) * Float64(c * c)))) + Float64(-0.5625 * Float64(Float64(a * a) / Float64((b ^ 5.0) / (c ^ 3.0))))); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.09], N[(N[(N[Sqrt[N[(b * b + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], N[(N[(-0.5 * N[(c / b), $MachinePrecision] + N[(-0.375 * N[(N[(a / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * N[(c * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-0.5625 * N[(N[(a * a), $MachinePrecision] / N[(N[Power[b, 5.0], $MachinePrecision] / N[Power[c, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.09:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(-3 \cdot c\right)\right)} - b}{\frac{a}{0.3333333333333333}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.5, \frac{c}{b}, -0.375 \cdot \left(\frac{a}{{b}^{3}} \cdot \left(c \cdot c\right)\right)\right) + -0.5625 \cdot \frac{a \cdot a}{\frac{{b}^{5}}{{c}^{3}}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.089999999999999997Initial program 82.2%
neg-sub082.2%
sqr-neg82.2%
associate-+l-82.2%
sub0-neg82.2%
neg-mul-182.2%
Simplified82.4%
if -0.089999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 44.6%
neg-sub044.6%
sqr-neg44.6%
associate-+l-44.6%
sub0-neg44.6%
neg-mul-144.6%
Simplified44.7%
div-inv44.7%
metadata-eval44.7%
*-commutative44.7%
add-sqr-sqrt44.7%
pow244.7%
Applied egg-rr44.7%
Taylor expanded in b around inf 91.4%
Simplified92.4%
Final simplification90.3%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.008) (/ (- (sqrt (fma b b (* a (* -3.0 c)))) b) (pow (sqrt (* a 3.0)) 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 (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = (sqrt(fma(b, b, (a * (-3.0 * c)))) - b) / pow(sqrt((a * 3.0)), 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 (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.008) tmp = Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(-3.0 * c)))) - b) / (sqrt(Float64(a * 3.0)) ^ 2.0)); else tmp = fma(-0.375, Float64(Float64(a / (b ^ 3.0)) * Float64(c * c)), 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[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.008], N[(N[(N[Sqrt[N[(b * b + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[Power[N[Sqrt[N[(a * 3.0), $MachinePrecision]], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(-0.375 * N[(N[(a / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * N[(c * c), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.008:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(-3 \cdot c\right)\right)} - b}{{\left(\sqrt{a \cdot 3}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.375, \frac{a}{{b}^{3}} \cdot \left(c \cdot c\right), -0.5 \cdot \frac{c}{b}\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.0080000000000000002Initial program 79.9%
neg-sub079.9%
sqr-neg79.9%
associate-+l-79.9%
sub0-neg79.9%
neg-mul-179.9%
Simplified80.1%
div-inv80.1%
metadata-eval80.1%
*-commutative80.1%
add-sqr-sqrt80.2%
pow280.2%
Applied egg-rr80.2%
if -0.0080000000000000002 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 42.0%
sqr-neg42.0%
sqr-neg42.0%
associate-*l*42.0%
Simplified42.0%
Taylor expanded in b around inf 89.7%
+-commutative89.7%
fma-def89.7%
associate-/l*89.7%
associate-/r/89.7%
unpow289.7%
Simplified89.7%
Final simplification87.1%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* -3.0 (* a c))))
(/
(/ t_0 (+ b (sqrt (fma b b t_0))))
(* (pow (cbrt a) 2.0) (* (cbrt a) 3.0)))))
double code(double a, double b, double c) {
double t_0 = -3.0 * (a * c);
return (t_0 / (b + sqrt(fma(b, b, t_0)))) / (pow(cbrt(a), 2.0) * (cbrt(a) * 3.0));
}
function code(a, b, c) t_0 = Float64(-3.0 * Float64(a * c)) return Float64(Float64(t_0 / Float64(b + sqrt(fma(b, b, t_0)))) / Float64((cbrt(a) ^ 2.0) * Float64(cbrt(a) * 3.0))) end
code[a_, b_, c_] := Block[{t$95$0 = N[(-3.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]}, N[(N[(t$95$0 / N[(b + N[Sqrt[N[(b * b + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Power[N[Power[a, 1/3], $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Power[a, 1/3], $MachinePrecision] * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -3 \cdot \left(a \cdot c\right)\\
\frac{\frac{t_0}{b + \sqrt{\mathsf{fma}\left(b, b, t_0\right)}}}{{\left(\sqrt[3]{a}\right)}^{2} \cdot \left(\sqrt[3]{a} \cdot 3\right)}
\end{array}
\end{array}
Initial program 52.5%
neg-sub052.5%
sqr-neg52.5%
associate-+l-52.5%
sub0-neg52.5%
neg-mul-152.5%
Simplified52.7%
div-inv52.7%
add-cube-cbrt52.6%
metadata-eval52.6%
associate-*l*52.6%
pow252.6%
Applied egg-rr52.6%
add-cbrt-cube52.6%
Applied egg-rr52.6%
flip--52.6%
add-sqr-sqrt54.1%
add-cbrt-cube54.1%
associate-*r*54.1%
Applied egg-rr54.1%
Taylor expanded in b around 0 97.8%
Final simplification97.8%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.008) (/ (- (sqrt (fma b b (* a (* -3.0 c)))) b) (/ a 0.3333333333333333)) (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 (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = (sqrt(fma(b, b, (a * (-3.0 * c)))) - b) / (a / 0.3333333333333333);
} 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 (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.008) tmp = Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(-3.0 * c)))) - b) / Float64(a / 0.3333333333333333)); else tmp = fma(-0.375, Float64(Float64(a / (b ^ 3.0)) * Float64(c * c)), 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[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.008], N[(N[(N[Sqrt[N[(b * b + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], N[(-0.375 * N[(N[(a / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * N[(c * c), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.008:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(-3 \cdot c\right)\right)} - b}{\frac{a}{0.3333333333333333}}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-0.375, \frac{a}{{b}^{3}} \cdot \left(c \cdot c\right), -0.5 \cdot \frac{c}{b}\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.0080000000000000002Initial program 79.9%
neg-sub079.9%
sqr-neg79.9%
associate-+l-79.9%
sub0-neg79.9%
neg-mul-179.9%
Simplified80.1%
if -0.0080000000000000002 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 42.0%
sqr-neg42.0%
sqr-neg42.0%
associate-*l*42.0%
Simplified42.0%
Taylor expanded in b around inf 89.7%
+-commutative89.7%
fma-def89.7%
associate-/l*89.7%
associate-/r/89.7%
unpow289.7%
Simplified89.7%
Final simplification87.0%
(FPCore (a b c)
:precision binary64
(if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.008)
(* 0.3333333333333333 (/ (- (sqrt (fma b b (* a (* -3.0 c)))) b) a))
(/
(+ (* -1.5 (* c (/ a b))) (* -1.125 (/ a (/ (/ (pow b 3.0) (* c c)) a))))
(* a 3.0))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = 0.3333333333333333 * ((sqrt(fma(b, b, (a * (-3.0 * c)))) - b) / a);
} else {
tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / ((pow(b, 3.0) / (c * c)) / a)))) / (a * 3.0);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.008) tmp = Float64(0.3333333333333333 * Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(-3.0 * c)))) - b) / a)); else tmp = Float64(Float64(Float64(-1.5 * Float64(c * Float64(a / b))) + Float64(-1.125 * Float64(a / Float64(Float64((b ^ 3.0) / Float64(c * c)) / a)))) / Float64(a * 3.0)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.008], N[(0.3333333333333333 * N[(N[(N[Sqrt[N[(b * b + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.5 * N[(c * N[(a / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.125 * N[(a / N[(N[(N[Power[b, 3.0], $MachinePrecision] / N[(c * c), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.008:\\
\;\;\;\;0.3333333333333333 \cdot \frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(-3 \cdot c\right)\right)} - b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1.5 \cdot \left(c \cdot \frac{a}{b}\right) + -1.125 \cdot \frac{a}{\frac{\frac{{b}^{3}}{c \cdot c}}{a}}}{a \cdot 3}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.0080000000000000002Initial program 79.9%
neg-sub079.9%
sqr-neg79.9%
associate-+l-79.9%
sub0-neg79.9%
neg-mul-179.9%
Simplified80.1%
div-inv80.1%
metadata-eval80.1%
*-commutative80.1%
add-cube-cbrt80.1%
pow380.1%
Applied egg-rr80.1%
div-sub79.7%
unpow379.1%
add-cube-cbrt76.1%
*-commutative76.1%
unpow376.2%
add-cube-cbrt79.5%
*-commutative79.5%
Applied egg-rr79.5%
div-sub80.1%
*-lft-identity80.1%
*-commutative80.1%
times-frac80.1%
metadata-eval80.1%
Simplified80.1%
if -0.0080000000000000002 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 42.0%
sqr-neg42.0%
sqr-neg42.0%
associate-*l*42.0%
Simplified42.0%
Taylor expanded in b around inf 89.2%
fma-def89.3%
associate-/l*89.3%
associate-/l*89.3%
unpow289.3%
unpow289.3%
Simplified89.3%
fma-udef89.3%
associate-/r/89.1%
associate-/l*89.1%
Applied egg-rr89.1%
Final simplification86.6%
(FPCore (a b c)
:precision binary64
(if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.008)
(/ (- (sqrt (fma b b (* a (* -3.0 c)))) b) (/ a 0.3333333333333333))
(/
(+ (* -1.5 (* c (/ a b))) (* -1.125 (/ a (/ (/ (pow b 3.0) (* c c)) a))))
(* a 3.0))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = (sqrt(fma(b, b, (a * (-3.0 * c)))) - b) / (a / 0.3333333333333333);
} else {
tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / ((pow(b, 3.0) / (c * c)) / a)))) / (a * 3.0);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.008) tmp = Float64(Float64(sqrt(fma(b, b, Float64(a * Float64(-3.0 * c)))) - b) / Float64(a / 0.3333333333333333)); else tmp = Float64(Float64(Float64(-1.5 * Float64(c * Float64(a / b))) + Float64(-1.125 * Float64(a / Float64(Float64((b ^ 3.0) / Float64(c * c)) / a)))) / Float64(a * 3.0)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.008], N[(N[(N[Sqrt[N[(b * b + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a / 0.3333333333333333), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.5 * N[(c * N[(a / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.125 * N[(a / N[(N[(N[Power[b, 3.0], $MachinePrecision] / N[(c * c), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.008:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, a \cdot \left(-3 \cdot c\right)\right)} - b}{\frac{a}{0.3333333333333333}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1.5 \cdot \left(c \cdot \frac{a}{b}\right) + -1.125 \cdot \frac{a}{\frac{\frac{{b}^{3}}{c \cdot c}}{a}}}{a \cdot 3}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.0080000000000000002Initial program 79.9%
neg-sub079.9%
sqr-neg79.9%
associate-+l-79.9%
sub0-neg79.9%
neg-mul-179.9%
Simplified80.1%
if -0.0080000000000000002 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 42.0%
sqr-neg42.0%
sqr-neg42.0%
associate-*l*42.0%
Simplified42.0%
Taylor expanded in b around inf 89.2%
fma-def89.3%
associate-/l*89.3%
associate-/l*89.3%
unpow289.3%
unpow289.3%
Simplified89.3%
fma-udef89.3%
associate-/r/89.1%
associate-/l*89.1%
Applied egg-rr89.1%
Final simplification86.6%
(FPCore (a b c)
:precision binary64
(if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -0.008)
(/ (- (sqrt (- (* b b) (* (* a c) 3.0))) b) (* a 3.0))
(/
(+ (* -1.5 (* c (/ a b))) (* -1.125 (/ a (/ (/ (pow b 3.0) (* c c)) a))))
(* a 3.0))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = (sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0);
} else {
tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / ((pow(b, 3.0) / (c * c)) / a)))) / (a * 3.0);
}
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 * (a * 3.0d0)))) - b) / (a * 3.0d0)) <= (-0.008d0)) then
tmp = (sqrt(((b * b) - ((a * c) * 3.0d0))) - b) / (a * 3.0d0)
else
tmp = (((-1.5d0) * (c * (a / b))) + ((-1.125d0) * (a / (((b ** 3.0d0) / (c * c)) / a)))) / (a * 3.0d0)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (((Math.sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) {
tmp = (Math.sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0);
} else {
tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / ((Math.pow(b, 3.0) / (c * c)) / a)))) / (a * 3.0);
}
return tmp;
}
def code(a, b, c): tmp = 0 if ((math.sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008: tmp = (math.sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0) else: tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / ((math.pow(b, 3.0) / (c * c)) / a)))) / (a * 3.0) return tmp
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 3.0)))) - b) / Float64(a * 3.0)) <= -0.008) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(a * c) * 3.0))) - b) / Float64(a * 3.0)); else tmp = Float64(Float64(Float64(-1.5 * Float64(c * Float64(a / b))) + Float64(-1.125 * Float64(a / Float64(Float64((b ^ 3.0) / Float64(c * c)) / a)))) / Float64(a * 3.0)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (((sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -0.008) tmp = (sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0); else tmp = ((-1.5 * (c * (a / b))) + (-1.125 * (a / (((b ^ 3.0) / (c * c)) / a)))) / (a * 3.0); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -0.008], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(a * c), $MachinePrecision] * 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.5 * N[(c * N[(a / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.125 * N[(a / N[(N[(N[Power[b, 3.0], $MachinePrecision] / N[(c * c), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 3\right)} - b}{a \cdot 3} \leq -0.008:\\
\;\;\;\;\frac{\sqrt{b \cdot b - \left(a \cdot c\right) \cdot 3} - b}{a \cdot 3}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1.5 \cdot \left(c \cdot \frac{a}{b}\right) + -1.125 \cdot \frac{a}{\frac{\frac{{b}^{3}}{c \cdot c}}{a}}}{a \cdot 3}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) < -0.0080000000000000002Initial program 79.9%
sqr-neg79.9%
sqr-neg79.9%
associate-*l*80.0%
Simplified80.0%
if -0.0080000000000000002 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 42.0%
sqr-neg42.0%
sqr-neg42.0%
associate-*l*42.0%
Simplified42.0%
Taylor expanded in b around inf 89.2%
fma-def89.3%
associate-/l*89.3%
associate-/l*89.3%
unpow289.3%
unpow289.3%
Simplified89.3%
fma-udef89.3%
associate-/r/89.1%
associate-/l*89.1%
Applied egg-rr89.1%
Final simplification86.6%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* c (* a 3.0)))) b) (* a 3.0)) -1.856e-6) (/ (- (sqrt (- (* 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 * (a * 3.0)))) - b) / (a * 3.0)) <= -1.856e-6) {
tmp = (sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0);
} 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 * (a * 3.0d0)))) - b) / (a * 3.0d0)) <= (-1.856d-6)) then
tmp = (sqrt(((b * b) - ((a * c) * 3.0d0))) - b) / (a * 3.0d0)
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 * (a * 3.0)))) - b) / (a * 3.0)) <= -1.856e-6) {
tmp = (Math.sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0);
} else {
tmp = -0.5 * (c / b);
}
return tmp;
}
def code(a, b, c): tmp = 0 if ((math.sqrt(((b * b) - (c * (a * 3.0)))) - b) / (a * 3.0)) <= -1.856e-6: tmp = (math.sqrt(((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(a * 3.0)))) - b) / Float64(a * 3.0)) <= -1.856e-6) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(a * c) * 3.0))) - b) / Float64(a * 3.0)); 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 * (a * 3.0)))) - b) / (a * 3.0)) <= -1.856e-6) tmp = (sqrt(((b * b) - ((a * c) * 3.0))) - b) / (a * 3.0); 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[(a * 3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $MachinePrecision]), $MachinePrecision], -1.856e-6], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(a * c), $MachinePrecision] * 3.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 3.0), $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(a \cdot 3\right)} - b}{a \cdot 3} \leq -1.856 \cdot 10^{-6}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - \left(a \cdot c\right) \cdot 3} - b}{a \cdot 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)) < -1.8560000000000001e-6Initial program 74.3%
sqr-neg74.3%
sqr-neg74.3%
associate-*l*74.4%
Simplified74.4%
if -1.8560000000000001e-6 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 3 a) c)))) (*.f64 3 a)) Initial program 31.7%
sqr-neg31.7%
sqr-neg31.7%
associate-*l*31.7%
Simplified31.7%
Taylor expanded in b around inf 83.2%
Final simplification78.9%
(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 52.5%
sqr-neg52.5%
sqr-neg52.5%
associate-*l*52.5%
Simplified52.5%
Taylor expanded in b around inf 66.1%
Final simplification66.1%
herbie shell --seed 2023275
(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)))