
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((4.0 * a) * c)))) / (2.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) - ((4.0d0 * a) * c)))) / (2.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c)))) / Float64(2.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}}{2 \cdot a}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((4.0 * a) * c)))) / (2.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) - ((4.0d0 * a) * c)))) / (2.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c)))) / Float64(2.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((4.0 * a) * c)))) / (2.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}}{2 \cdot a}
\end{array}
(FPCore (a b c)
:precision binary64
(let* ((t_0 (/ c (pow b 4.0))) (t_1 (* (* 4.0 a) c)))
(if (<= (/ (+ (- b) (sqrt (- (* b b) t_1))) (* 2.0 a)) -49.0)
(/
(* (fma b b (fma (- b) b t_1)) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(pow a -1.0)
(*
b
(-
(-
(pow (* b b) -1.0)
(/ (* (fma (* c c) -3.0 (* c c)) (* a a)) (pow b 6.0)))
(fma -2.0 (* a t_0) (fma a t_0 (/ (pow a -1.0) c)))))))))
double code(double a, double b, double c) {
double t_0 = c / pow(b, 4.0);
double t_1 = (4.0 * a) * c;
double tmp;
if (((-b + sqrt(((b * b) - t_1))) / (2.0 * a)) <= -49.0) {
tmp = (fma(b, b, fma(-b, b, t_1)) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (b * ((pow((b * b), -1.0) - ((fma((c * c), -3.0, (c * c)) * (a * a)) / pow(b, 6.0))) - fma(-2.0, (a * t_0), fma(a, t_0, (pow(a, -1.0) / c)))));
}
return tmp;
}
function code(a, b, c) t_0 = Float64(c / (b ^ 4.0)) t_1 = Float64(Float64(4.0 * a) * c) tmp = 0.0 if (Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - t_1))) / Float64(2.0 * a)) <= -49.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, t_1)) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(b * Float64(Float64((Float64(b * b) ^ -1.0) - Float64(Float64(fma(Float64(c * c), -3.0, Float64(c * c)) * Float64(a * a)) / (b ^ 6.0))) - fma(-2.0, Float64(a * t_0), fma(a, t_0, Float64((a ^ -1.0) / c)))))); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(c / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]}, If[LessEqual[N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], -49.0], N[(N[(N[(b * b + N[((-b) * b + t$95$1), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(b * N[(N[(N[Power[N[(b * b), $MachinePrecision], -1.0], $MachinePrecision] - N[(N[(N[(N[(c * c), $MachinePrecision] * -3.0 + N[(c * c), $MachinePrecision]), $MachinePrecision] * N[(a * a), $MachinePrecision]), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(-2.0 * N[(a * t$95$0), $MachinePrecision] + N[(a * t$95$0 + N[(N[Power[a, -1.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c}{{b}^{4}}\\
t_1 := \left(4 \cdot a\right) \cdot c\\
\mathbf{if}\;\frac{\left(-b\right) + \sqrt{b \cdot b - t\_1}}{2 \cdot a} \leq -49:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, t\_1\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{b \cdot \left(\left({\left(b \cdot b\right)}^{-1} - \frac{\mathsf{fma}\left(c \cdot c, -3, c \cdot c\right) \cdot \left(a \cdot a\right)}{{b}^{6}}\right) - \mathsf{fma}\left(-2, a \cdot t\_0, \mathsf{fma}\left(a, t\_0, \frac{{a}^{-1}}{c}\right)\right)\right)}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) < -49Initial program 89.6%
Applied rewrites89.5%
Applied rewrites88.7%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites88.4%
Applied rewrites91.0%
if -49 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) Initial program 51.0%
Applied rewrites51.0%
Taylor expanded in b around inf
Applied rewrites94.2%
Taylor expanded in a around 0
Applied rewrites94.2%
Final simplification93.9%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* (* 4.0 a) c)))
(if (<= (/ (+ (- b) (sqrt (- (* b b) t_0))) (* 2.0 a)) -49.0)
(/
(* (fma b b (fma (- b) b t_0)) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(pow a -1.0)
(/
(fma
(fma
(fma (* (* a a) (/ c (pow b 5.0))) 2.0 (/ a (pow b 3.0)))
c
(pow b -1.0))
c
(/ (- b) a))
c)))))
double code(double a, double b, double c) {
double t_0 = (4.0 * a) * c;
double tmp;
if (((-b + sqrt(((b * b) - t_0))) / (2.0 * a)) <= -49.0) {
tmp = (fma(b, b, fma(-b, b, t_0)) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (fma(fma(fma(((a * a) * (c / pow(b, 5.0))), 2.0, (a / pow(b, 3.0))), c, pow(b, -1.0)), c, (-b / a)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = Float64(Float64(4.0 * a) * c) tmp = 0.0 if (Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - t_0))) / Float64(2.0 * a)) <= -49.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, t_0)) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(fma(fma(fma(Float64(Float64(a * a) * Float64(c / (b ^ 5.0))), 2.0, Float64(a / (b ^ 3.0))), c, (b ^ -1.0)), c, Float64(Float64(-b) / a)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]}, If[LessEqual[N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], -49.0], N[(N[(N[(b * b + N[((-b) * b + t$95$0), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(N[(N[(N[(N[(N[(a * a), $MachinePrecision] * N[(c / N[Power[b, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 2.0 + N[(a / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c + N[Power[b, -1.0], $MachinePrecision]), $MachinePrecision] * c + N[((-b) / a), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(4 \cdot a\right) \cdot c\\
\mathbf{if}\;\frac{\left(-b\right) + \sqrt{b \cdot b - t\_0}}{2 \cdot a} \leq -49:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, t\_0\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{\frac{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(\left(a \cdot a\right) \cdot \frac{c}{{b}^{5}}, 2, \frac{a}{{b}^{3}}\right), c, {b}^{-1}\right), c, \frac{-b}{a}\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) < -49Initial program 89.6%
Applied rewrites89.5%
Applied rewrites88.7%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites88.4%
Applied rewrites91.0%
if -49 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) Initial program 51.0%
Applied rewrites51.0%
Applied rewrites51.9%
Taylor expanded in c around 0
lower-/.f64N/A
Applied rewrites94.2%
Final simplification93.9%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(pow a -1.0)
(/ (fma (fma a (/ c (pow b 3.0)) (pow b -1.0)) a (/ (- b) c)) a))))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (fma(fma(a, (c / pow(b, 3.0)), pow(b, -1.0)), a, (-b / c)) / a);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(fma(fma(a, Float64(c / (b ^ 3.0)), (b ^ -1.0)), a, Float64(Float64(-b) / c)) / a)); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(N[(N[(a * N[(c / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] + N[Power[b, -1.0], $MachinePrecision]), $MachinePrecision] * a + N[((-b) / c), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{\frac{\mathsf{fma}\left(\mathsf{fma}\left(a, \frac{c}{{b}^{3}}, {b}^{-1}\right), a, \frac{-b}{c}\right)}{a}}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Applied rewrites44.0%
Taylor expanded in a around 0
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-pow.f64N/A
lower-/.f64N/A
associate-*r/N/A
mul-1-negN/A
lower-/.f64N/A
lower-neg.f6495.0
Applied rewrites95.0%
Final simplification92.3%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* (* 4.0 a) c)))
(if (<= (/ (+ (- b) (sqrt (- (* b b) t_0))) (* 2.0 a)) -49.0)
(/
(* (fma b b (fma (- b) b t_0)) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(*
c
(fma
c
(fma
c
(/
(fma (* -5.0 (pow a 3.0)) c (* (* (* a a) -2.0) (* b b)))
(pow b 6.0))
(/ (- a) (* b b)))
-1.0))
b))))
double code(double a, double b, double c) {
double t_0 = (4.0 * a) * c;
double tmp;
if (((-b + sqrt(((b * b) - t_0))) / (2.0 * a)) <= -49.0) {
tmp = (fma(b, b, fma(-b, b, t_0)) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = (c * fma(c, fma(c, (fma((-5.0 * pow(a, 3.0)), c, (((a * a) * -2.0) * (b * b))) / pow(b, 6.0)), (-a / (b * b))), -1.0)) / b;
}
return tmp;
}
function code(a, b, c) t_0 = Float64(Float64(4.0 * a) * c) tmp = 0.0 if (Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - t_0))) / Float64(2.0 * a)) <= -49.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, t_0)) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64(Float64(c * fma(c, fma(c, Float64(fma(Float64(-5.0 * (a ^ 3.0)), c, Float64(Float64(Float64(a * a) * -2.0) * Float64(b * b))) / (b ^ 6.0)), Float64(Float64(-a) / Float64(b * b))), -1.0)) / b); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]}, If[LessEqual[N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], -49.0], N[(N[(N[(b * b + N[((-b) * b + t$95$0), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[(c * N[(c * N[(c * N[(N[(N[(-5.0 * N[Power[a, 3.0], $MachinePrecision]), $MachinePrecision] * c + N[(N[(N[(a * a), $MachinePrecision] * -2.0), $MachinePrecision] * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision] + N[((-a) / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(4 \cdot a\right) \cdot c\\
\mathbf{if}\;\frac{\left(-b\right) + \sqrt{b \cdot b - t\_0}}{2 \cdot a} \leq -49:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, t\_0\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{c \cdot \mathsf{fma}\left(c, \mathsf{fma}\left(c, \frac{\mathsf{fma}\left(-5 \cdot {a}^{3}, c, \left(\left(a \cdot a\right) \cdot -2\right) \cdot \left(b \cdot b\right)\right)}{{b}^{6}}, \frac{-a}{b \cdot b}\right), -1\right)}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) < -49Initial program 89.6%
Applied rewrites89.5%
Applied rewrites88.7%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites88.4%
Applied rewrites91.0%
if -49 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 4 binary64) a) c)))) (*.f64 #s(literal 2 binary64) a)) Initial program 51.0%
Taylor expanded in b around inf
Applied rewrites94.1%
Taylor expanded in c around 0
Applied rewrites94.0%
Taylor expanded in b around 0
Applied rewrites94.0%
Final simplification93.7%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/ (pow a -1.0) (* b (- (pow (* b b) -1.0) (/ (pow a -1.0) c))))))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (b * (pow((b * b), -1.0) - (pow(a, -1.0) / c)));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(b * Float64((Float64(b * b) ^ -1.0) - Float64((a ^ -1.0) / c)))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(b * N[(N[Power[N[(b * b), $MachinePrecision], -1.0], $MachinePrecision] - N[(N[Power[a, -1.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{b \cdot \left({\left(b \cdot b\right)}^{-1} - \frac{{a}^{-1}}{c}\right)}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
lower-/.f6490.7
Applied rewrites90.7%
Final simplification89.1%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(fma
a
(- (/ (* -2.0 (* a (pow c 3.0))) (pow b 4.0)) (* (/ c b) (/ c b)))
(- c))
b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = fma(a, (((-2.0 * (a * pow(c, 3.0))) / pow(b, 4.0)) - ((c / b) * (c / b))), -c) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64(fma(a, Float64(Float64(Float64(-2.0 * Float64(a * (c ^ 3.0))) / (b ^ 4.0)) - Float64(Float64(c / b) * Float64(c / b))), Float64(-c)) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[(a * N[(N[(N[(-2.0 * N[(a * N[Power[c, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision] - N[(N[(c / b), $MachinePrecision] * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + (-c)), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(a, \frac{-2 \cdot \left(a \cdot {c}^{3}\right)}{{b}^{4}} - \frac{c}{b} \cdot \frac{c}{b}, -c\right)}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Taylor expanded in b around inf
Applied rewrites96.9%
Taylor expanded in a around 0
Applied rewrites95.2%
Final simplification92.4%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(*
(fma
(fma (* -2.0 c) (* a (/ a (pow b 5.0))) (/ (- a) (pow b 3.0)))
c
(/ -1.0 b))
c)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = fma(fma((-2.0 * c), (a * (a / pow(b, 5.0))), (-a / pow(b, 3.0))), c, (-1.0 / b)) * c;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64(fma(fma(Float64(-2.0 * c), Float64(a * Float64(a / (b ^ 5.0))), Float64(Float64(-a) / (b ^ 3.0))), c, Float64(-1.0 / b)) * c); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(-2.0 * c), $MachinePrecision] * N[(a * N[(a / N[Power[b, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[((-a) / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-2 \cdot c, a \cdot \frac{a}{{b}^{5}}, \frac{-a}{{b}^{3}}\right), c, \frac{-1}{b}\right) \cdot c\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites95.0%
Final simplification92.3%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/ (pow a -1.0) (* b (/ (- (/ c (* b b)) (pow a -1.0)) c)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (b * (((c / (b * b)) - pow(a, -1.0)) / c));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(b * Float64(Float64(Float64(c / Float64(b * b)) - (a ^ -1.0)) / c))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(b * N[(N[(N[(c / N[(b * b), $MachinePrecision]), $MachinePrecision] - N[Power[a, -1.0], $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{b \cdot \frac{\frac{c}{b \cdot b} - {a}^{-1}}{c}}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in c around 0
Applied rewrites90.6%
Final simplification89.1%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/
(* c (fma c (- (/ (* -2.0 (* (* a a) c)) (pow b 4.0)) (/ a (* b b))) -1.0))
b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = (c * fma(c, (((-2.0 * ((a * a) * c)) / pow(b, 4.0)) - (a / (b * b))), -1.0)) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64(Float64(c * fma(c, Float64(Float64(Float64(-2.0 * Float64(Float64(a * a) * c)) / (b ^ 4.0)) - Float64(a / Float64(b * b))), -1.0)) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[(c * N[(c * N[(N[(N[(-2.0 * N[(N[(a * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision] - N[(a / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{c \cdot \mathsf{fma}\left(c, \frac{-2 \cdot \left(\left(a \cdot a\right) \cdot c\right)}{{b}^{4}} - \frac{a}{b \cdot b}, -1\right)}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Taylor expanded in b around inf
Applied rewrites96.9%
Taylor expanded in c around 0
Applied rewrites95.0%
Final simplification92.3%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/ (pow a -1.0) (/ (- (/ a b) (/ b c)) a))))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = pow(a, -1.0) / (((a / b) - (b / c)) / a);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64((a ^ -1.0) / Float64(Float64(Float64(a / b) - Float64(b / c)) / a)); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[Power[a, -1.0], $MachinePrecision] / N[(N[(N[(a / b), $MachinePrecision] - N[(b / c), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{{a}^{-1}}{\frac{\frac{a}{b} - \frac{b}{c}}{a}}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in a around 0
lower-/.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f6490.6
Applied rewrites90.6%
Final simplification89.1%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(* (fma b b (fma (- b) b (* (* 4.0 a) c))) (/ 0.5 (- a)))
(+ (sqrt (fma (* -4.0 c) a (* b b))) b))
(/ (- (- c) (/ (* a (* c c)) (* b b))) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (fma(b, b, fma(-b, b, ((4.0 * a) * c))) * (0.5 / -a)) / (sqrt(fma((-4.0 * c), a, (b * b))) + b);
} else {
tmp = (-c - ((a * (c * c)) / (b * b))) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c))) * Float64(0.5 / Float64(-a))) / Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b)); else tmp = Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.5 / (-a)), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right) \cdot \frac{0.5}{-a}}{\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites85.0%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in a around 0
Applied rewrites96.8%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification89.0%
(FPCore (a b c)
:precision binary64
(if (<= b 37.0)
(/
(- (fma b b (fma (- b) b (* (* 4.0 a) c))))
(* (* 2.0 a) (+ (sqrt (fma (* -4.0 c) a (* b b))) b)))
(/ (- (- c) (/ (* a (* c c)) (* b b))) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = -fma(b, b, fma(-b, b, ((4.0 * a) * c))) / ((2.0 * a) * (sqrt(fma((-4.0 * c), a, (b * b))) + b));
} else {
tmp = (-c - ((a * (c * c)) / (b * b))) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(-fma(b, b, fma(Float64(-b), b, Float64(Float64(4.0 * a) * c)))) / Float64(Float64(2.0 * a) * Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) + b))); else tmp = Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[((-N[(b * b + N[((-b) * b + N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]) / N[(N[(2.0 * a), $MachinePrecision] * N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{-\mathsf{fma}\left(b, b, \mathsf{fma}\left(-b, b, \left(4 \cdot a\right) \cdot c\right)\right)}{\left(2 \cdot a\right) \cdot \left(\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} + b\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites83.9%
lift--.f64N/A
sub-negN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites83.5%
Applied rewrites84.9%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in a around 0
Applied rewrites96.8%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification88.9%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -4.0 a) c (* b b))))
(if (<= b 37.0)
(/ (- (* b b) t_0) (* (* 2.0 a) (- (- b) (sqrt t_0))))
(/ (- (- c) (/ (* a (* c c)) (* b b))) b))))
double code(double a, double b, double c) {
double t_0 = fma((-4.0 * a), c, (b * b));
double tmp;
if (b <= 37.0) {
tmp = ((b * b) - t_0) / ((2.0 * a) * (-b - sqrt(t_0)));
} else {
tmp = (-c - ((a * (c * c)) / (b * b))) / b;
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-4.0 * a), c, Float64(b * b)) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(Float64(b * b) - t_0) / Float64(Float64(2.0 * a) * Float64(Float64(-b) - sqrt(t_0)))); else tmp = Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-4.0 * a), $MachinePrecision] * c + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, 37.0], N[(N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision] / N[(N[(2.0 * a), $MachinePrecision] * N[((-b) - N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-4 \cdot a, c, b \cdot b\right)\\
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{b \cdot b - t\_0}{\left(2 \cdot a\right) \cdot \left(\left(-b\right) - \sqrt{t\_0}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
Applied rewrites83.1%
Applied rewrites84.7%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in a around 0
Applied rewrites96.8%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification88.9%
(FPCore (a b c) :precision binary64 (if (<= b 37.0) (/ (+ (- b) (sqrt (fma b b (* (* -4.0 c) a)))) (* 2.0 a)) (/ (- (- c) (/ (* a (* c c)) (* b b))) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (-b + sqrt(fma(b, b, ((-4.0 * c) * a)))) / (2.0 * a);
} else {
tmp = (-c - ((a * (c * c)) / (b * b))) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(Float64(-b) + sqrt(fma(b, b, Float64(Float64(-4.0 * c) * a)))) / Float64(2.0 * a)); else tmp = Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[((-b) + N[Sqrt[N[(b * b + N[(N[(-4.0 * c), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{\left(-b\right) + \sqrt{\mathsf{fma}\left(b, b, \left(-4 \cdot c\right) \cdot a\right)}}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
lift--.f64N/A
sub-negN/A
lift-*.f64N/A
lower-fma.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
distribute-lft-neg-inN/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval83.4
Applied rewrites83.4%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in a around 0
Applied rewrites96.8%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification88.5%
(FPCore (a b c) :precision binary64 (if (<= b 37.0) (* (/ 0.5 a) (- (sqrt (fma (* -4.0 c) a (* b b))) b)) (/ (- (- c) (/ (* a (* c c)) (* b b))) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 37.0) {
tmp = (0.5 / a) * (sqrt(fma((-4.0 * c), a, (b * b))) - b);
} else {
tmp = (-c - ((a * (c * c)) / (b * b))) / b;
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 37.0) tmp = Float64(Float64(0.5 / a) * Float64(sqrt(fma(Float64(-4.0 * c), a, Float64(b * b))) - b)); else tmp = Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 37.0], N[(N[(0.5 / a), $MachinePrecision] * N[(N[Sqrt[N[(N[(-4.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision], N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 37:\\
\;\;\;\;\frac{0.5}{a} \cdot \left(\sqrt{\mathsf{fma}\left(-4 \cdot c, a, b \cdot b\right)} - b\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}\\
\end{array}
\end{array}
if b < 37Initial program 83.1%
lift-/.f64N/A
clear-numN/A
associate-/r/N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/r*N/A
metadata-evalN/A
lower-/.f6483.1
lift-+.f64N/A
+-commutativeN/A
lift-neg.f64N/A
unsub-negN/A
lower--.f6483.1
Applied rewrites83.1%
if 37 < b Initial program 43.3%
Applied rewrites43.3%
Taylor expanded in b around inf
Applied rewrites96.8%
Taylor expanded in a around 0
Applied rewrites96.8%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6490.5
Applied rewrites90.5%
Final simplification88.5%
(FPCore (a b c) :precision binary64 (/ (- (- c) (/ (* a (* c c)) (* b b))) b))
double code(double a, double b, double c) {
return (-c - ((a * (c * c)) / (b * b))) / b;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (-c - ((a * (c * c)) / (b * b))) / b
end function
public static double code(double a, double b, double c) {
return (-c - ((a * (c * c)) / (b * b))) / b;
}
def code(a, b, c): return (-c - ((a * (c * c)) / (b * b))) / b
function code(a, b, c) return Float64(Float64(Float64(-c) - Float64(Float64(a * Float64(c * c)) / Float64(b * b))) / b) end
function tmp = code(a, b, c) tmp = (-c - ((a * (c * c)) / (b * b))) / b; end
code[a_, b_, c_] := N[(N[((-c) - N[(N[(a * N[(c * c), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-c\right) - \frac{a \cdot \left(c \cdot c\right)}{b \cdot b}}{b}
\end{array}
Initial program 54.2%
Applied rewrites54.2%
Taylor expanded in b around inf
Applied rewrites92.1%
Taylor expanded in a around 0
Applied rewrites92.1%
Taylor expanded in b around inf
lower-/.f64N/A
distribute-lft-outN/A
lower-*.f64N/A
lower-+.f64N/A
lower-/.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6481.6
Applied rewrites81.6%
Final simplification81.6%
(FPCore (a b c) :precision binary64 (/ (- c) b))
double code(double a, double b, double c) {
return -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 = -c / b
end function
public static double code(double a, double b, double c) {
return -c / b;
}
def code(a, b, c): return -c / b
function code(a, b, c) return Float64(Float64(-c) / b) end
function tmp = code(a, b, c) tmp = -c / b; end
code[a_, b_, c_] := N[((-c) / b), $MachinePrecision]
\begin{array}{l}
\\
\frac{-c}{b}
\end{array}
Initial program 54.2%
Taylor expanded in a around 0
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6464.7
Applied rewrites64.7%
(FPCore (a b c) :precision binary64 (/ c b))
double code(double a, double b, double c) {
return 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 = c / b
end function
public static double code(double a, double b, double c) {
return c / b;
}
def code(a, b, c): return c / b
function code(a, b, c) return Float64(c / b) end
function tmp = code(a, b, c) tmp = c / b; end
code[a_, b_, c_] := N[(c / b), $MachinePrecision]
\begin{array}{l}
\\
\frac{c}{b}
\end{array}
Initial program 54.2%
Taylor expanded in a around 0
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6464.7
Applied rewrites64.7%
Applied rewrites64.7%
Applied rewrites64.7%
Applied rewrites1.6%
herbie shell --seed 2024319
(FPCore (a b c)
:name "Quadratic roots, 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) (* (* 4.0 a) c)))) (* 2.0 a)))