
(FPCore (a b c) :precision binary64 (let* ((t_0 (sqrt (- (* b b) (* (* 4.0 a) c))))) (if (>= b 0.0) (/ (* 2.0 c) (- (- b) t_0)) (/ (+ (- b) t_0) (* 2.0 a)))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (-b - t_0);
} else {
tmp = (-b + t_0) / (2.0 * a);
}
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) :: t_0
real(8) :: tmp
t_0 = sqrt(((b * b) - ((4.0d0 * a) * c)))
if (b >= 0.0d0) then
tmp = (2.0d0 * c) / (-b - t_0)
else
tmp = (-b + t_0) / (2.0d0 * a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (-b - t_0);
} else {
tmp = (-b + t_0) / (2.0 * a);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) - ((4.0 * a) * c))) tmp = 0 if b >= 0.0: tmp = (2.0 * c) / (-b - t_0) else: tmp = (-b + t_0) / (2.0 * a) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c))) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(2.0 * c) / Float64(Float64(-b) - t_0)); else tmp = Float64(Float64(Float64(-b) + t_0) / Float64(2.0 * a)); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt(((b * b) - ((4.0 * a) * c))); tmp = 0.0; if (b >= 0.0) tmp = (2.0 * c) / (-b - t_0); else tmp = (-b + t_0) / (2.0 * a); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[((-b) - t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[((-b) + t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}\\
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{\left(-b\right) - t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-b\right) + t\_0}{2 \cdot a}\\
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b c) :precision binary64 (let* ((t_0 (sqrt (- (* b b) (* (* 4.0 a) c))))) (if (>= b 0.0) (/ (* 2.0 c) (- (- b) t_0)) (/ (+ (- b) t_0) (* 2.0 a)))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (-b - t_0);
} else {
tmp = (-b + t_0) / (2.0 * a);
}
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) :: t_0
real(8) :: tmp
t_0 = sqrt(((b * b) - ((4.0d0 * a) * c)))
if (b >= 0.0d0) then
tmp = (2.0d0 * c) / (-b - t_0)
else
tmp = (-b + t_0) / (2.0d0 * a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (-b - t_0);
} else {
tmp = (-b + t_0) / (2.0 * a);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) - ((4.0 * a) * c))) tmp = 0 if b >= 0.0: tmp = (2.0 * c) / (-b - t_0) else: tmp = (-b + t_0) / (2.0 * a) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c))) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(2.0 * c) / Float64(Float64(-b) - t_0)); else tmp = Float64(Float64(Float64(-b) + t_0) / Float64(2.0 * a)); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt(((b * b) - ((4.0 * a) * c))); tmp = 0.0; if (b >= 0.0) tmp = (2.0 * c) / (-b - t_0); else tmp = (-b + t_0) / (2.0 * a); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[((-b) - t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[((-b) + t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}\\
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{\left(-b\right) - t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(-b\right) + t\_0}{2 \cdot a}\\
\end{array}
\end{array}
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (- (* b b) (* c (* a 4.0))))) (t_1 (fma a (/ c b) (- b))))
(if (<= b -1e+90)
(if (>= b 0.0) (/ (* 2.0 c) (* 2.0 t_1)) (/ t_1 a))
(if (<= b 1.5e+104)
(if (>= b 0.0) (/ (* 2.0 c) (- (- b) t_0)) (/ (- t_0 b) (* 2.0 a)))
(if (>= b 0.0)
(/ (* 2.0 c) (* 2.0 (- (* a (/ c b)) b)))
(/ b (- a)))))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) - (c * (a * 4.0))));
double t_1 = fma(a, (c / b), -b);
double tmp_1;
if (b <= -1e+90) {
double tmp_2;
if (b >= 0.0) {
tmp_2 = (2.0 * c) / (2.0 * t_1);
} else {
tmp_2 = t_1 / a;
}
tmp_1 = tmp_2;
} else if (b <= 1.5e+104) {
double tmp_3;
if (b >= 0.0) {
tmp_3 = (2.0 * c) / (-b - t_0);
} else {
tmp_3 = (t_0 - b) / (2.0 * a);
}
tmp_1 = tmp_3;
} else if (b >= 0.0) {
tmp_1 = (2.0 * c) / (2.0 * ((a * (c / b)) - b));
} else {
tmp_1 = b / -a;
}
return tmp_1;
}
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) t_1 = fma(a, Float64(c / b), Float64(-b)) tmp_1 = 0.0 if (b <= -1e+90) tmp_2 = 0.0 if (b >= 0.0) tmp_2 = Float64(Float64(2.0 * c) / Float64(2.0 * t_1)); else tmp_2 = Float64(t_1 / a); end tmp_1 = tmp_2; elseif (b <= 1.5e+104) tmp_3 = 0.0 if (b >= 0.0) tmp_3 = Float64(Float64(2.0 * c) / Float64(Float64(-b) - t_0)); else tmp_3 = Float64(Float64(t_0 - b) / Float64(2.0 * a)); end tmp_1 = tmp_3; elseif (b >= 0.0) tmp_1 = Float64(Float64(2.0 * c) / Float64(2.0 * Float64(Float64(a * Float64(c / b)) - b))); else tmp_1 = Float64(b / Float64(-a)); end return tmp_1 end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, If[LessEqual[b, -1e+90], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$1), $MachinePrecision]), $MachinePrecision], N[(t$95$1 / a), $MachinePrecision]], If[LessEqual[b, 1.5e+104], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[((-b) - t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$0 - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * N[(N[(a * N[(c / b), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b / (-a)), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)}\\
t_1 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
\mathbf{if}\;b \leq -1 \cdot 10^{+90}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_1}{a}\\
\end{array}\\
\mathbf{elif}\;b \leq 1.5 \cdot 10^{+104}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{\left(-b\right) - t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0 - b}{2 \cdot a}\\
\end{array}\\
\mathbf{elif}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot \left(a \cdot \frac{c}{b} - b\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{-a}\\
\end{array}
\end{array}
if b < -9.99999999999999966e89Initial program 56.6%
Taylor expanded in a around 0 56.6%
distribute-lft-out--56.6%
associate-/l*56.6%
fma-neg56.6%
Simplified56.6%
div-inv56.5%
neg-mul-156.5%
fma-define56.5%
pow256.5%
associate-*l*56.5%
Applied egg-rr56.5%
associate-/r*56.5%
metadata-eval56.5%
metadata-eval56.5%
associate-*r/56.5%
*-commutative56.5%
associate-*r/56.5%
metadata-eval56.5%
fma-undefine56.5%
+-commutative56.5%
neg-mul-156.5%
sub-neg56.5%
cancel-sign-sub-inv56.5%
metadata-eval56.5%
associate-*r*56.5%
*-commutative56.5%
*-commutative56.5%
+-commutative56.5%
fma-define56.6%
Simplified56.6%
Taylor expanded in b around -inf 97.4%
associate-*r*97.4%
neg-mul-197.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Taylor expanded in a around 0 92.4%
neg-mul-192.4%
+-commutative92.4%
associate-/l*98.1%
fma-define98.1%
Simplified98.1%
if -9.99999999999999966e89 < b < 1.49999999999999984e104Initial program 84.1%
if 1.49999999999999984e104 < b Initial program 53.2%
Taylor expanded in a around 0 89.3%
distribute-lft-out--89.3%
associate-/l*97.8%
fma-neg97.8%
Simplified97.8%
Taylor expanded in b around -inf 97.8%
associate-*r/97.8%
neg-mul-197.8%
Simplified97.8%
fma-undefine97.8%
Applied egg-rr97.8%
Final simplification90.0%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma a (/ c b) (- b))) (t_1 (/ (* 2.0 c) (* 2.0 t_0))))
(if (<= b -1e+90)
(if (>= b 0.0) t_1 (/ t_0 a))
(if (>= b 0.0)
t_1
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))))))
double code(double a, double b, double c) {
double t_0 = fma(a, (c / b), -b);
double t_1 = (2.0 * c) / (2.0 * t_0);
double tmp_1;
if (b <= -1e+90) {
double tmp_2;
if (b >= 0.0) {
tmp_2 = t_1;
} else {
tmp_2 = t_0 / a;
}
tmp_1 = tmp_2;
} else if (b >= 0.0) {
tmp_1 = t_1;
} else {
tmp_1 = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
}
return tmp_1;
}
function code(a, b, c) t_0 = fma(a, Float64(c / b), Float64(-b)) t_1 = Float64(Float64(2.0 * c) / Float64(2.0 * t_0)) tmp_1 = 0.0 if (b <= -1e+90) tmp_2 = 0.0 if (b >= 0.0) tmp_2 = t_1; else tmp_2 = Float64(t_0 / a); end tmp_1 = tmp_2; elseif (b >= 0.0) tmp_1 = t_1; else tmp_1 = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); end return tmp_1 end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, Block[{t$95$1 = N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1e+90], If[GreaterEqual[b, 0.0], t$95$1, N[(t$95$0 / a), $MachinePrecision]], If[GreaterEqual[b, 0.0], t$95$1, N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
t_1 := \frac{2 \cdot c}{2 \cdot t\_0}\\
\mathbf{if}\;b \leq -1 \cdot 10^{+90}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{a}\\
\end{array}\\
\mathbf{elif}\;b \geq 0:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\end{array}
\end{array}
if b < -9.99999999999999966e89Initial program 56.6%
Taylor expanded in a around 0 56.6%
distribute-lft-out--56.6%
associate-/l*56.6%
fma-neg56.6%
Simplified56.6%
div-inv56.5%
neg-mul-156.5%
fma-define56.5%
pow256.5%
associate-*l*56.5%
Applied egg-rr56.5%
associate-/r*56.5%
metadata-eval56.5%
metadata-eval56.5%
associate-*r/56.5%
*-commutative56.5%
associate-*r/56.5%
metadata-eval56.5%
fma-undefine56.5%
+-commutative56.5%
neg-mul-156.5%
sub-neg56.5%
cancel-sign-sub-inv56.5%
metadata-eval56.5%
associate-*r*56.5%
*-commutative56.5%
*-commutative56.5%
+-commutative56.5%
fma-define56.6%
Simplified56.6%
Taylor expanded in b around -inf 97.4%
associate-*r*97.4%
neg-mul-197.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Taylor expanded in a around 0 92.4%
neg-mul-192.4%
+-commutative92.4%
associate-/l*98.1%
fma-define98.1%
Simplified98.1%
if -9.99999999999999966e89 < b Initial program 76.9%
Taylor expanded in a around 0 71.6%
distribute-lft-out--71.6%
associate-/l*73.6%
fma-neg73.6%
Simplified73.6%
Final simplification79.8%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma a (/ c b) (- b))))
(if (<= b -1.7e+89)
(if (>= b 0.0) (/ (* 2.0 c) (* 2.0 t_0)) (/ t_0 a))
(if (>= b 0.0)
(/ 1.0 (fma -1.0 (/ b c) (/ a b)))
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))))))
double code(double a, double b, double c) {
double t_0 = fma(a, (c / b), -b);
double tmp_1;
if (b <= -1.7e+89) {
double tmp_2;
if (b >= 0.0) {
tmp_2 = (2.0 * c) / (2.0 * t_0);
} else {
tmp_2 = t_0 / a;
}
tmp_1 = tmp_2;
} else if (b >= 0.0) {
tmp_1 = 1.0 / fma(-1.0, (b / c), (a / b));
} else {
tmp_1 = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
}
return tmp_1;
}
function code(a, b, c) t_0 = fma(a, Float64(c / b), Float64(-b)) tmp_1 = 0.0 if (b <= -1.7e+89) tmp_2 = 0.0 if (b >= 0.0) tmp_2 = Float64(Float64(2.0 * c) / Float64(2.0 * t_0)); else tmp_2 = Float64(t_0 / a); end tmp_1 = tmp_2; elseif (b >= 0.0) tmp_1 = Float64(1.0 / fma(-1.0, Float64(b / c), Float64(a / b))); else tmp_1 = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); end return tmp_1 end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, If[LessEqual[b, -1.7e+89], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / a), $MachinePrecision]], If[GreaterEqual[b, 0.0], N[(1.0 / N[(-1.0 * N[(b / c), $MachinePrecision] + N[(a / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
\mathbf{if}\;b \leq -1.7 \cdot 10^{+89}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{a}\\
\end{array}\\
\mathbf{elif}\;b \geq 0:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(-1, \frac{b}{c}, \frac{a}{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\end{array}
\end{array}
if b < -1.7000000000000001e89Initial program 56.6%
Taylor expanded in a around 0 56.6%
distribute-lft-out--56.6%
associate-/l*56.6%
fma-neg56.6%
Simplified56.6%
div-inv56.5%
neg-mul-156.5%
fma-define56.5%
pow256.5%
associate-*l*56.5%
Applied egg-rr56.5%
associate-/r*56.5%
metadata-eval56.5%
metadata-eval56.5%
associate-*r/56.5%
*-commutative56.5%
associate-*r/56.5%
metadata-eval56.5%
fma-undefine56.5%
+-commutative56.5%
neg-mul-156.5%
sub-neg56.5%
cancel-sign-sub-inv56.5%
metadata-eval56.5%
associate-*r*56.5%
*-commutative56.5%
*-commutative56.5%
+-commutative56.5%
fma-define56.6%
Simplified56.6%
Taylor expanded in b around -inf 97.4%
associate-*r*97.4%
neg-mul-197.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Taylor expanded in a around 0 92.4%
neg-mul-192.4%
+-commutative92.4%
associate-/l*98.1%
fma-define98.1%
Simplified98.1%
if -1.7000000000000001e89 < b Initial program 76.9%
add-sqr-sqrt54.0%
pow254.0%
*-commutative54.0%
Applied egg-rr54.0%
clear-num54.0%
inv-pow54.0%
pow254.0%
associate-*l*54.0%
unpow254.0%
add-sqr-sqrt76.8%
*-commutative76.8%
Applied egg-rr76.8%
unpow-176.8%
cancel-sign-sub-inv76.8%
metadata-eval76.8%
associate-*r*76.8%
*-commutative76.8%
*-commutative76.8%
+-commutative76.8%
fma-define76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in a around 0 73.6%
fma-define73.6%
Simplified73.6%
Final simplification79.7%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma a (/ c b) (- b))))
(if (<= b -5e+89)
(if (>= b 0.0) (/ (* 2.0 c) (* 2.0 t_0)) (/ t_0 a))
(if (>= b 0.0)
(/ 1.0 (/ t_0 c))
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))))))
double code(double a, double b, double c) {
double t_0 = fma(a, (c / b), -b);
double tmp_1;
if (b <= -5e+89) {
double tmp_2;
if (b >= 0.0) {
tmp_2 = (2.0 * c) / (2.0 * t_0);
} else {
tmp_2 = t_0 / a;
}
tmp_1 = tmp_2;
} else if (b >= 0.0) {
tmp_1 = 1.0 / (t_0 / c);
} else {
tmp_1 = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
}
return tmp_1;
}
function code(a, b, c) t_0 = fma(a, Float64(c / b), Float64(-b)) tmp_1 = 0.0 if (b <= -5e+89) tmp_2 = 0.0 if (b >= 0.0) tmp_2 = Float64(Float64(2.0 * c) / Float64(2.0 * t_0)); else tmp_2 = Float64(t_0 / a); end tmp_1 = tmp_2; elseif (b >= 0.0) tmp_1 = Float64(1.0 / Float64(t_0 / c)); else tmp_1 = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); end return tmp_1 end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, If[LessEqual[b, -5e+89], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / a), $MachinePrecision]], If[GreaterEqual[b, 0.0], N[(1.0 / N[(t$95$0 / c), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
\mathbf{if}\;b \leq -5 \cdot 10^{+89}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{a}\\
\end{array}\\
\mathbf{elif}\;b \geq 0:\\
\;\;\;\;\frac{1}{\frac{t\_0}{c}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\end{array}
\end{array}
if b < -4.99999999999999983e89Initial program 56.6%
Taylor expanded in a around 0 56.6%
distribute-lft-out--56.6%
associate-/l*56.6%
fma-neg56.6%
Simplified56.6%
div-inv56.5%
neg-mul-156.5%
fma-define56.5%
pow256.5%
associate-*l*56.5%
Applied egg-rr56.5%
associate-/r*56.5%
metadata-eval56.5%
metadata-eval56.5%
associate-*r/56.5%
*-commutative56.5%
associate-*r/56.5%
metadata-eval56.5%
fma-undefine56.5%
+-commutative56.5%
neg-mul-156.5%
sub-neg56.5%
cancel-sign-sub-inv56.5%
metadata-eval56.5%
associate-*r*56.5%
*-commutative56.5%
*-commutative56.5%
+-commutative56.5%
fma-define56.6%
Simplified56.6%
Taylor expanded in b around -inf 97.4%
associate-*r*97.4%
neg-mul-197.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Taylor expanded in a around 0 92.4%
neg-mul-192.4%
+-commutative92.4%
associate-/l*98.1%
fma-define98.1%
Simplified98.1%
if -4.99999999999999983e89 < b Initial program 76.9%
Taylor expanded in a around 0 71.6%
distribute-lft-out--71.6%
associate-/l*73.6%
fma-neg73.6%
Simplified73.6%
clear-num73.5%
inv-pow73.5%
Applied egg-rr73.5%
unpow-173.5%
times-frac73.5%
metadata-eval73.5%
Simplified73.5%
Final simplification79.7%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma a (/ c b) (- b))))
(if (<= b -1e+90)
(if (>= b 0.0) (/ (* 2.0 c) (* 2.0 t_0)) (/ t_0 a))
(if (>= b 0.0)
(* -0.5 (* c (/ 2.0 b)))
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))))))
double code(double a, double b, double c) {
double t_0 = fma(a, (c / b), -b);
double tmp_1;
if (b <= -1e+90) {
double tmp_2;
if (b >= 0.0) {
tmp_2 = (2.0 * c) / (2.0 * t_0);
} else {
tmp_2 = t_0 / a;
}
tmp_1 = tmp_2;
} else if (b >= 0.0) {
tmp_1 = -0.5 * (c * (2.0 / b));
} else {
tmp_1 = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
}
return tmp_1;
}
function code(a, b, c) t_0 = fma(a, Float64(c / b), Float64(-b)) tmp_1 = 0.0 if (b <= -1e+90) tmp_2 = 0.0 if (b >= 0.0) tmp_2 = Float64(Float64(2.0 * c) / Float64(2.0 * t_0)); else tmp_2 = Float64(t_0 / a); end tmp_1 = tmp_2; elseif (b >= 0.0) tmp_1 = Float64(-0.5 * Float64(c * Float64(2.0 / b))); else tmp_1 = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); end return tmp_1 end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, If[LessEqual[b, -1e+90], If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / a), $MachinePrecision]], If[GreaterEqual[b, 0.0], N[(-0.5 * N[(c * N[(2.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
\mathbf{if}\;b \leq -1 \cdot 10^{+90}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{a}\\
\end{array}\\
\mathbf{elif}\;b \geq 0:\\
\;\;\;\;-0.5 \cdot \left(c \cdot \frac{2}{b}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\end{array}
\end{array}
if b < -9.99999999999999966e89Initial program 56.6%
Taylor expanded in a around 0 56.6%
distribute-lft-out--56.6%
associate-/l*56.6%
fma-neg56.6%
Simplified56.6%
div-inv56.5%
neg-mul-156.5%
fma-define56.5%
pow256.5%
associate-*l*56.5%
Applied egg-rr56.5%
associate-/r*56.5%
metadata-eval56.5%
metadata-eval56.5%
associate-*r/56.5%
*-commutative56.5%
associate-*r/56.5%
metadata-eval56.5%
fma-undefine56.5%
+-commutative56.5%
neg-mul-156.5%
sub-neg56.5%
cancel-sign-sub-inv56.5%
metadata-eval56.5%
associate-*r*56.5%
*-commutative56.5%
*-commutative56.5%
+-commutative56.5%
fma-define56.6%
Simplified56.6%
Taylor expanded in b around -inf 97.4%
associate-*r*97.4%
neg-mul-197.4%
+-commutative97.4%
mul-1-neg97.4%
unsub-neg97.4%
Simplified97.4%
Taylor expanded in a around 0 92.4%
neg-mul-192.4%
+-commutative92.4%
associate-/l*98.1%
fma-define98.1%
Simplified98.1%
if -9.99999999999999966e89 < b Initial program 76.9%
add-sqr-sqrt54.0%
pow254.0%
*-commutative54.0%
Applied egg-rr54.0%
Taylor expanded in c around 0 72.9%
associate-/l*72.9%
unpow272.9%
rem-square-sqrt73.4%
Simplified73.4%
Final simplification79.6%
(FPCore (a b c) :precision binary64 (if (>= b 0.0) (/ (* 2.0 c) (* 2.0 (fma a (/ c b) (- b)))) (fma -1.0 (/ b a) (/ c b))))
double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (2.0 * fma(a, (c / b), -b));
} else {
tmp = fma(-1.0, (b / a), (c / b));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(2.0 * c) / Float64(2.0 * fma(a, Float64(c / b), Float64(-b)))); else tmp = fma(-1.0, Float64(b / a), Float64(c / b)); end return tmp end
code[a_, b_, c_] := If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 * N[(b / a), $MachinePrecision] + N[(c / b), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot \mathsf{fma}\left(a, \frac{c}{b}, -b\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-1, \frac{b}{a}, \frac{c}{b}\right)\\
\end{array}
\end{array}
Initial program 71.8%
Taylor expanded in a around 0 67.9%
distribute-lft-out--67.9%
associate-/l*69.4%
fma-neg69.4%
Simplified69.4%
div-inv69.3%
neg-mul-169.3%
fma-define69.3%
pow269.3%
associate-*l*69.3%
Applied egg-rr69.3%
associate-/r*69.3%
metadata-eval69.3%
metadata-eval69.3%
associate-*r/69.3%
*-commutative69.3%
associate-*r/69.3%
metadata-eval69.3%
fma-undefine69.3%
+-commutative69.3%
neg-mul-169.3%
sub-neg69.3%
cancel-sign-sub-inv69.3%
metadata-eval69.3%
associate-*r*69.3%
*-commutative69.3%
*-commutative69.3%
+-commutative69.3%
fma-define69.3%
Simplified69.3%
Taylor expanded in b around -inf 66.8%
associate-*r*66.8%
neg-mul-166.8%
+-commutative66.8%
mul-1-neg66.8%
unsub-neg66.8%
Simplified66.8%
Taylor expanded in a around inf 67.5%
fma-define67.5%
Simplified67.5%
(FPCore (a b c) :precision binary64 (let* ((t_0 (fma a (/ c b) (- b)))) (if (>= b 0.0) (/ (* 2.0 c) (* 2.0 t_0)) (/ t_0 a))))
double code(double a, double b, double c) {
double t_0 = fma(a, (c / b), -b);
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (2.0 * t_0);
} else {
tmp = t_0 / a;
}
return tmp;
}
function code(a, b, c) t_0 = fma(a, Float64(c / b), Float64(-b)) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(2.0 * c) / Float64(2.0 * t_0)); else tmp = Float64(t_0 / a); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c / b), $MachinePrecision] + (-b)), $MachinePrecision]}, If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * t$95$0), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(a, \frac{c}{b}, -b\right)\\
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{a}\\
\end{array}
\end{array}
Initial program 71.8%
Taylor expanded in a around 0 67.9%
distribute-lft-out--67.9%
associate-/l*69.4%
fma-neg69.4%
Simplified69.4%
div-inv69.3%
neg-mul-169.3%
fma-define69.3%
pow269.3%
associate-*l*69.3%
Applied egg-rr69.3%
associate-/r*69.3%
metadata-eval69.3%
metadata-eval69.3%
associate-*r/69.3%
*-commutative69.3%
associate-*r/69.3%
metadata-eval69.3%
fma-undefine69.3%
+-commutative69.3%
neg-mul-169.3%
sub-neg69.3%
cancel-sign-sub-inv69.3%
metadata-eval69.3%
associate-*r*69.3%
*-commutative69.3%
*-commutative69.3%
+-commutative69.3%
fma-define69.3%
Simplified69.3%
Taylor expanded in b around -inf 66.8%
associate-*r*66.8%
neg-mul-166.8%
+-commutative66.8%
mul-1-neg66.8%
unsub-neg66.8%
Simplified66.8%
Taylor expanded in a around 0 66.0%
neg-mul-166.0%
+-commutative66.0%
associate-/l*67.5%
fma-define67.5%
Simplified67.5%
(FPCore (a b c) :precision binary64 (if (>= b 0.0) (/ (* 2.0 c) (* 2.0 (- (* a (/ c b)) b))) (/ b (- a))))
double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (2.0 * ((a * (c / b)) - b));
} else {
tmp = b / -a;
}
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 >= 0.0d0) then
tmp = (2.0d0 * c) / (2.0d0 * ((a * (c / b)) - b))
else
tmp = b / -a
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = (2.0 * c) / (2.0 * ((a * (c / b)) - b));
} else {
tmp = b / -a;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b >= 0.0: tmp = (2.0 * c) / (2.0 * ((a * (c / b)) - b)) else: tmp = b / -a return tmp
function code(a, b, c) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(2.0 * c) / Float64(2.0 * Float64(Float64(a * Float64(c / b)) - b))); else tmp = Float64(b / Float64(-a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b >= 0.0) tmp = (2.0 * c) / (2.0 * ((a * (c / b)) - b)); else tmp = b / -a; end tmp_2 = tmp; end
code[a_, b_, c_] := If[GreaterEqual[b, 0.0], N[(N[(2.0 * c), $MachinePrecision] / N[(2.0 * N[(N[(a * N[(c / b), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b / (-a)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{2 \cdot c}{2 \cdot \left(a \cdot \frac{c}{b} - b\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{-a}\\
\end{array}
\end{array}
Initial program 71.8%
Taylor expanded in a around 0 67.9%
distribute-lft-out--67.9%
associate-/l*69.4%
fma-neg69.4%
Simplified69.4%
Taylor expanded in b around -inf 67.3%
associate-*r/67.3%
neg-mul-167.3%
Simplified67.3%
fma-undefine67.3%
Applied egg-rr67.3%
Final simplification67.3%
(FPCore (a b c) :precision binary64 (if (>= b 0.0) (/ c (- b)) (/ b (- a))))
double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = c / -b;
} else {
tmp = b / -a;
}
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 >= 0.0d0) then
tmp = c / -b
else
tmp = b / -a
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = c / -b;
} else {
tmp = b / -a;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b >= 0.0: tmp = c / -b else: tmp = b / -a return tmp
function code(a, b, c) tmp = 0.0 if (b >= 0.0) tmp = Float64(c / Float64(-b)); else tmp = Float64(b / Float64(-a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b >= 0.0) tmp = c / -b; else tmp = b / -a; end tmp_2 = tmp; end
code[a_, b_, c_] := If[GreaterEqual[b, 0.0], N[(c / (-b)), $MachinePrecision], N[(b / (-a)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{c}{-b}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{-a}\\
\end{array}
\end{array}
Initial program 71.8%
Taylor expanded in a around 0 67.9%
distribute-lft-out--67.9%
associate-/l*69.4%
fma-neg69.4%
Simplified69.4%
Taylor expanded in b around -inf 67.3%
associate-*r/67.3%
neg-mul-167.3%
Simplified67.3%
Taylor expanded in c around 0 67.1%
associate-*r/67.1%
mul-1-neg67.1%
Simplified67.1%
Final simplification67.1%
(FPCore (a b c) :precision binary64 (if (>= b 0.0) (/ b a) (/ b (- a))))
double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = b / a;
} else {
tmp = b / -a;
}
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 >= 0.0d0) then
tmp = b / a
else
tmp = b / -a
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = b / a;
} else {
tmp = b / -a;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b >= 0.0: tmp = b / a else: tmp = b / -a return tmp
function code(a, b, c) tmp = 0.0 if (b >= 0.0) tmp = Float64(b / a); else tmp = Float64(b / Float64(-a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b >= 0.0) tmp = b / a; else tmp = b / -a; end tmp_2 = tmp; end
code[a_, b_, c_] := If[GreaterEqual[b, 0.0], N[(b / a), $MachinePrecision], N[(b / (-a)), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{b}{-a}\\
\end{array}
\end{array}
Initial program 71.8%
Taylor expanded in a around 0 67.9%
distribute-lft-out--67.9%
associate-/l*69.4%
fma-neg69.4%
Simplified69.4%
Taylor expanded in b around -inf 67.3%
associate-*r/67.3%
neg-mul-167.3%
Simplified67.3%
Taylor expanded in c around inf 39.8%
Final simplification39.8%
herbie shell --seed 2024131
(FPCore (a b c)
:name "jeff quadratic root 2"
:precision binary64
(if (>= b 0.0) (/ (* 2.0 c) (- (- b) (sqrt (- (* b b) (* (* 4.0 a) c))))) (/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a))))