
(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 12 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 (* a 4.0))))
(if (<= b -5e+126)
(- (/ c b) (/ b a))
(if (<= b 1.5e-127)
(/ (- (sqrt (- (* b b) t_0)) b) (* a 2.0))
(if (<= b 2.8e-10)
(/ (/ t_0 (- (- b) (sqrt (fma b b (* c (* a -4.0)))))) (* a 2.0))
(- (/ (- c) b) (/ c (/ (/ (pow b 3.0) a) c))))))))
double code(double a, double b, double c) {
double t_0 = c * (a * 4.0);
double tmp;
if (b <= -5e+126) {
tmp = (c / b) - (b / a);
} else if (b <= 1.5e-127) {
tmp = (sqrt(((b * b) - t_0)) - b) / (a * 2.0);
} else if (b <= 2.8e-10) {
tmp = (t_0 / (-b - sqrt(fma(b, b, (c * (a * -4.0)))))) / (a * 2.0);
} else {
tmp = (-c / b) - (c / ((pow(b, 3.0) / a) / c));
}
return tmp;
}
function code(a, b, c) t_0 = Float64(c * Float64(a * 4.0)) tmp = 0.0 if (b <= -5e+126) tmp = Float64(Float64(c / b) - Float64(b / a)); elseif (b <= 1.5e-127) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - t_0)) - b) / Float64(a * 2.0)); elseif (b <= 2.8e-10) tmp = Float64(Float64(t_0 / Float64(Float64(-b) - sqrt(fma(b, b, Float64(c * Float64(a * -4.0)))))) / Float64(a * 2.0)); else tmp = Float64(Float64(Float64(-c) / b) - Float64(c / Float64(Float64((b ^ 3.0) / a) / c))); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5e+126], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.5e-127], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.8e-10], N[(N[(t$95$0 / N[((-b) - N[Sqrt[N[(b * b + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[((-c) / b), $MachinePrecision] - N[(c / N[(N[(N[Power[b, 3.0], $MachinePrecision] / a), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := c \cdot \left(a \cdot 4\right)\\
\mathbf{if}\;b \leq -5 \cdot 10^{+126}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{elif}\;b \leq 1.5 \cdot 10^{-127}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - t_0} - b}{a \cdot 2}\\
\mathbf{elif}\;b \leq 2.8 \cdot 10^{-10}:\\
\;\;\;\;\frac{\frac{t_0}{\left(-b\right) - \sqrt{\mathsf{fma}\left(b, b, c \cdot \left(a \cdot -4\right)\right)}}}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b} - \frac{c}{\frac{\frac{{b}^{3}}{a}}{c}}\\
\end{array}
\end{array}
if b < -4.99999999999999977e126Initial program 46.9%
neg-sub046.9%
associate-+l-46.9%
sub0-neg46.9%
neg-mul-146.9%
associate-*l/46.9%
*-commutative46.9%
associate-/r*46.9%
/-rgt-identity46.9%
metadata-eval46.9%
Simplified47.0%
Taylor expanded in b around -inf 93.9%
mul-1-neg93.9%
unsub-neg93.9%
Simplified93.9%
if -4.99999999999999977e126 < b < 1.50000000000000004e-127Initial program 85.4%
if 1.50000000000000004e-127 < b < 2.80000000000000015e-10Initial program 67.5%
add-cube-cbrt67.2%
pow367.0%
add-sqr-sqrt66.8%
cbrt-prod66.7%
cbrt-prod66.8%
add-sqr-sqrt67.0%
*-commutative67.0%
*-commutative67.0%
Applied egg-rr67.0%
flip-+66.8%
pow266.8%
add-sqr-sqrt66.8%
rem-cube-cbrt67.0%
rem-cube-cbrt67.3%
Applied egg-rr67.3%
Simplified85.4%
*-un-lft-identity85.4%
+-lft-identity85.4%
associate-*r*85.2%
*-commutative85.2%
*-commutative85.2%
associate-*r*85.2%
Applied egg-rr85.2%
*-lft-identity85.2%
associate-*l*85.4%
Simplified85.4%
if 2.80000000000000015e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 83.0%
+-commutative83.0%
mul-1-neg83.0%
unsub-neg83.0%
associate-*r/83.0%
neg-mul-183.0%
associate-/l*84.4%
unpow284.4%
associate-/l*95.9%
Simplified95.9%
Final simplification89.8%
(FPCore (a b c)
:precision binary64
(if (<= b -2e+124)
(- (/ c b) (/ b a))
(if (<= b 3.8e-248)
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* a 2.0))
(if (<= b 3.2e-10)
(/ (* 2.0 (/ (* c a) a)) (- (- b) (sqrt (fma b b (* c (* a -4.0))))))
(- (/ (- c) b) (/ c (/ (/ (pow b 3.0) a) c)))))))
double code(double a, double b, double c) {
double tmp;
if (b <= -2e+124) {
tmp = (c / b) - (b / a);
} else if (b <= 3.8e-248) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (a * 2.0);
} else if (b <= 3.2e-10) {
tmp = (2.0 * ((c * a) / a)) / (-b - sqrt(fma(b, b, (c * (a * -4.0)))));
} else {
tmp = (-c / b) - (c / ((pow(b, 3.0) / a) / c));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= -2e+124) tmp = Float64(Float64(c / b) - Float64(b / a)); elseif (b <= 3.8e-248) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(a * 2.0)); elseif (b <= 3.2e-10) tmp = Float64(Float64(2.0 * Float64(Float64(c * a) / a)) / Float64(Float64(-b) - sqrt(fma(b, b, Float64(c * Float64(a * -4.0)))))); else tmp = Float64(Float64(Float64(-c) / b) - Float64(c / Float64(Float64((b ^ 3.0) / a) / c))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, -2e+124], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.8e-248], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.2e-10], N[(N[(2.0 * N[(N[(c * a), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision] / N[((-b) - N[Sqrt[N[(b * b + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-c) / b), $MachinePrecision] - N[(c / N[(N[(N[Power[b, 3.0], $MachinePrecision] / a), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2 \cdot 10^{+124}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{elif}\;b \leq 3.8 \cdot 10^{-248}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{a \cdot 2}\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{-10}:\\
\;\;\;\;\frac{2 \cdot \frac{c \cdot a}{a}}{\left(-b\right) - \sqrt{\mathsf{fma}\left(b, b, c \cdot \left(a \cdot -4\right)\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b} - \frac{c}{\frac{\frac{{b}^{3}}{a}}{c}}\\
\end{array}
\end{array}
if b < -1.9999999999999999e124Initial program 46.9%
neg-sub046.9%
associate-+l-46.9%
sub0-neg46.9%
neg-mul-146.9%
associate-*l/46.9%
*-commutative46.9%
associate-/r*46.9%
/-rgt-identity46.9%
metadata-eval46.9%
Simplified47.0%
Taylor expanded in b around -inf 93.9%
mul-1-neg93.9%
unsub-neg93.9%
Simplified93.9%
if -1.9999999999999999e124 < b < 3.7999999999999999e-248Initial program 87.9%
if 3.7999999999999999e-248 < b < 3.19999999999999981e-10Initial program 68.9%
add-cube-cbrt68.6%
pow368.5%
add-sqr-sqrt68.4%
cbrt-prod67.9%
cbrt-prod68.4%
add-sqr-sqrt68.5%
*-commutative68.5%
*-commutative68.5%
Applied egg-rr68.5%
flip-+68.4%
pow268.4%
add-sqr-sqrt68.4%
rem-cube-cbrt68.4%
rem-cube-cbrt68.8%
Applied egg-rr68.8%
Simplified80.0%
*-un-lft-identity80.0%
associate-/l/71.2%
+-lft-identity71.2%
associate-*r*71.2%
*-commutative71.2%
*-commutative71.2%
*-commutative71.2%
associate-*r*71.2%
Applied egg-rr71.2%
*-lft-identity71.2%
associate-/r*80.0%
*-commutative80.0%
*-commutative80.0%
times-frac80.0%
metadata-eval80.0%
Simplified80.0%
if 3.19999999999999981e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 83.0%
+-commutative83.0%
mul-1-neg83.0%
unsub-neg83.0%
associate-*r/83.0%
neg-mul-183.0%
associate-/l*84.4%
unpow284.4%
associate-/l*95.9%
Simplified95.9%
Final simplification89.8%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (* c (* a -4.0))))
(t_1 (- (/ c b) (/ b a)))
(t_2 (* (- b t_0) (/ -0.5 a)))
(t_3 (/ (* 0.5 (- t_0 b)) a)))
(if (<= b -7.8e-22)
t_1
(if (<= b -2.4e-42)
t_2
(if (<= b -4.1e-56)
(/ (- b) a)
(if (<= b -4.4e-91)
t_3
(if (<= b -2.65e-138)
t_1
(if (<= b 3.4e-137)
t_3
(if (<= b 1e-76)
(/ 1.0 (- (/ a b) (/ b c)))
(if (<= b 1.08e-10)
t_2
(- (/ (- c) b) (/ c (/ (/ (pow b 3.0) a) c)))))))))))))
double code(double a, double b, double c) {
double t_0 = sqrt((c * (a * -4.0)));
double t_1 = (c / b) - (b / a);
double t_2 = (b - t_0) * (-0.5 / a);
double t_3 = (0.5 * (t_0 - b)) / a;
double tmp;
if (b <= -7.8e-22) {
tmp = t_1;
} else if (b <= -2.4e-42) {
tmp = t_2;
} else if (b <= -4.1e-56) {
tmp = -b / a;
} else if (b <= -4.4e-91) {
tmp = t_3;
} else if (b <= -2.65e-138) {
tmp = t_1;
} else if (b <= 3.4e-137) {
tmp = t_3;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_2;
} else {
tmp = (-c / b) - (c / ((pow(b, 3.0) / a) / c));
}
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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = sqrt((c * (a * (-4.0d0))))
t_1 = (c / b) - (b / a)
t_2 = (b - t_0) * ((-0.5d0) / a)
t_3 = (0.5d0 * (t_0 - b)) / a
if (b <= (-7.8d-22)) then
tmp = t_1
else if (b <= (-2.4d-42)) then
tmp = t_2
else if (b <= (-4.1d-56)) then
tmp = -b / a
else if (b <= (-4.4d-91)) then
tmp = t_3
else if (b <= (-2.65d-138)) then
tmp = t_1
else if (b <= 3.4d-137) then
tmp = t_3
else if (b <= 1d-76) then
tmp = 1.0d0 / ((a / b) - (b / c))
else if (b <= 1.08d-10) then
tmp = t_2
else
tmp = (-c / b) - (c / (((b ** 3.0d0) / a) / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt((c * (a * -4.0)));
double t_1 = (c / b) - (b / a);
double t_2 = (b - t_0) * (-0.5 / a);
double t_3 = (0.5 * (t_0 - b)) / a;
double tmp;
if (b <= -7.8e-22) {
tmp = t_1;
} else if (b <= -2.4e-42) {
tmp = t_2;
} else if (b <= -4.1e-56) {
tmp = -b / a;
} else if (b <= -4.4e-91) {
tmp = t_3;
} else if (b <= -2.65e-138) {
tmp = t_1;
} else if (b <= 3.4e-137) {
tmp = t_3;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_2;
} else {
tmp = (-c / b) - (c / ((Math.pow(b, 3.0) / a) / c));
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt((c * (a * -4.0))) t_1 = (c / b) - (b / a) t_2 = (b - t_0) * (-0.5 / a) t_3 = (0.5 * (t_0 - b)) / a tmp = 0 if b <= -7.8e-22: tmp = t_1 elif b <= -2.4e-42: tmp = t_2 elif b <= -4.1e-56: tmp = -b / a elif b <= -4.4e-91: tmp = t_3 elif b <= -2.65e-138: tmp = t_1 elif b <= 3.4e-137: tmp = t_3 elif b <= 1e-76: tmp = 1.0 / ((a / b) - (b / c)) elif b <= 1.08e-10: tmp = t_2 else: tmp = (-c / b) - (c / ((math.pow(b, 3.0) / a) / c)) return tmp
function code(a, b, c) t_0 = sqrt(Float64(c * Float64(a * -4.0))) t_1 = Float64(Float64(c / b) - Float64(b / a)) t_2 = Float64(Float64(b - t_0) * Float64(-0.5 / a)) t_3 = Float64(Float64(0.5 * Float64(t_0 - b)) / a) tmp = 0.0 if (b <= -7.8e-22) tmp = t_1; elseif (b <= -2.4e-42) tmp = t_2; elseif (b <= -4.1e-56) tmp = Float64(Float64(-b) / a); elseif (b <= -4.4e-91) tmp = t_3; elseif (b <= -2.65e-138) tmp = t_1; elseif (b <= 3.4e-137) tmp = t_3; elseif (b <= 1e-76) tmp = Float64(1.0 / Float64(Float64(a / b) - Float64(b / c))); elseif (b <= 1.08e-10) tmp = t_2; else tmp = Float64(Float64(Float64(-c) / b) - Float64(c / Float64(Float64((b ^ 3.0) / a) / c))); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt((c * (a * -4.0))); t_1 = (c / b) - (b / a); t_2 = (b - t_0) * (-0.5 / a); t_3 = (0.5 * (t_0 - b)) / a; tmp = 0.0; if (b <= -7.8e-22) tmp = t_1; elseif (b <= -2.4e-42) tmp = t_2; elseif (b <= -4.1e-56) tmp = -b / a; elseif (b <= -4.4e-91) tmp = t_3; elseif (b <= -2.65e-138) tmp = t_1; elseif (b <= 3.4e-137) tmp = t_3; elseif (b <= 1e-76) tmp = 1.0 / ((a / b) - (b / c)); elseif (b <= 1.08e-10) tmp = t_2; else tmp = (-c / b) - (c / (((b ^ 3.0) / a) / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b - t$95$0), $MachinePrecision] * N[(-0.5 / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(0.5 * N[(t$95$0 - b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[b, -7.8e-22], t$95$1, If[LessEqual[b, -2.4e-42], t$95$2, If[LessEqual[b, -4.1e-56], N[((-b) / a), $MachinePrecision], If[LessEqual[b, -4.4e-91], t$95$3, If[LessEqual[b, -2.65e-138], t$95$1, If[LessEqual[b, 3.4e-137], t$95$3, If[LessEqual[b, 1e-76], N[(1.0 / N[(N[(a / b), $MachinePrecision] - N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.08e-10], t$95$2, N[(N[((-c) / b), $MachinePrecision] - N[(c / N[(N[(N[Power[b, 3.0], $MachinePrecision] / a), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{c \cdot \left(a \cdot -4\right)}\\
t_1 := \frac{c}{b} - \frac{b}{a}\\
t_2 := \left(b - t_0\right) \cdot \frac{-0.5}{a}\\
t_3 := \frac{0.5 \cdot \left(t_0 - b\right)}{a}\\
\mathbf{if}\;b \leq -7.8 \cdot 10^{-22}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -2.4 \cdot 10^{-42}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -4.1 \cdot 10^{-56}:\\
\;\;\;\;\frac{-b}{a}\\
\mathbf{elif}\;b \leq -4.4 \cdot 10^{-91}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq -2.65 \cdot 10^{-138}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 3.4 \cdot 10^{-137}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 10^{-76}:\\
\;\;\;\;\frac{1}{\frac{a}{b} - \frac{b}{c}}\\
\mathbf{elif}\;b \leq 1.08 \cdot 10^{-10}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b} - \frac{c}{\frac{\frac{{b}^{3}}{a}}{c}}\\
\end{array}
\end{array}
if b < -7.79999999999999996e-22 or -4.4000000000000002e-91 < b < -2.65000000000000013e-138Initial program 68.7%
neg-sub068.7%
associate-+l-68.7%
sub0-neg68.7%
neg-mul-168.7%
associate-*l/68.6%
*-commutative68.6%
associate-/r*68.6%
/-rgt-identity68.6%
metadata-eval68.6%
Simplified68.6%
Taylor expanded in b around -inf 84.8%
mul-1-neg84.8%
unsub-neg84.8%
Simplified84.8%
if -7.79999999999999996e-22 < b < -2.40000000000000003e-42 or 9.99999999999999927e-77 < b < 1.08000000000000002e-10Initial program 94.4%
neg-sub094.4%
associate-+l-94.4%
sub0-neg94.4%
neg-mul-194.4%
associate-*l/94.5%
*-commutative94.5%
associate-/r*94.5%
/-rgt-identity94.5%
metadata-eval94.5%
Simplified94.5%
Taylor expanded in a around inf 89.5%
*-commutative89.5%
associate-*r*89.5%
Simplified89.5%
if -2.40000000000000003e-42 < b < -4.1000000000000001e-56Initial program 100.0%
neg-sub0100.0%
associate-+l-100.0%
sub0-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
*-commutative100.0%
associate-/r*100.0%
/-rgt-identity100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in b around -inf 100.0%
associate-*r/100.0%
neg-mul-1100.0%
Simplified100.0%
if -4.1000000000000001e-56 < b < -4.4000000000000002e-91 or -2.65000000000000013e-138 < b < 3.40000000000000014e-137Initial program 83.2%
/-rgt-identity83.2%
metadata-eval83.2%
associate-/l*83.2%
associate-*r/83.1%
+-commutative83.1%
unsub-neg83.1%
fma-neg83.1%
associate-*l*83.1%
*-commutative83.1%
distribute-rgt-neg-in83.1%
metadata-eval83.1%
associate-/r*83.1%
metadata-eval83.1%
metadata-eval83.1%
Simplified83.1%
fma-udef83.1%
associate-*l*83.1%
Applied egg-rr83.1%
Taylor expanded in b around 0 79.2%
*-commutative79.2%
associate-*r*79.2%
Simplified79.2%
associate-*r/79.3%
Applied egg-rr79.3%
if 3.40000000000000014e-137 < b < 9.99999999999999927e-77Initial program 39.1%
clear-num38.9%
inv-pow38.9%
*-commutative38.9%
neg-mul-138.9%
fma-def38.9%
*-commutative38.9%
*-commutative38.9%
Applied egg-rr38.9%
unpow-138.9%
associate-/l*38.9%
Applied egg-rr38.9%
Taylor expanded in b around inf 52.9%
neg-mul-152.9%
sub-neg52.9%
Simplified52.9%
if 1.08000000000000002e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 83.0%
+-commutative83.0%
mul-1-neg83.0%
unsub-neg83.0%
associate-*r/83.0%
neg-mul-183.0%
associate-/l*84.4%
unpow284.4%
associate-/l*95.9%
Simplified95.9%
Final simplification85.2%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (- (/ c b) (/ b a)))
(t_1 (* (- b (sqrt (* c (* a -4.0)))) (/ -0.5 a))))
(if (<= b -1.08e-26)
t_0
(if (<= b -5.6e-45)
t_1
(if (<= b -7.8e-56)
(/ (- b) a)
(if (<= b -6.5e-88)
t_1
(if (<= b -1.75e-135)
t_0
(if (<= b 3.2e-136)
t_1
(if (<= b 1e-76)
(/ 1.0 (- (/ a b) (/ b c)))
(if (<= b 1.08e-10) t_1 (/ (- c) b)))))))))))
double code(double a, double b, double c) {
double t_0 = (c / b) - (b / a);
double t_1 = (b - sqrt((c * (a * -4.0)))) * (-0.5 / a);
double tmp;
if (b <= -1.08e-26) {
tmp = t_0;
} else if (b <= -5.6e-45) {
tmp = t_1;
} else if (b <= -7.8e-56) {
tmp = -b / a;
} else if (b <= -6.5e-88) {
tmp = t_1;
} else if (b <= -1.75e-135) {
tmp = t_0;
} else if (b <= 3.2e-136) {
tmp = t_1;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_1;
} else {
tmp = -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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (c / b) - (b / a)
t_1 = (b - sqrt((c * (a * (-4.0d0))))) * ((-0.5d0) / a)
if (b <= (-1.08d-26)) then
tmp = t_0
else if (b <= (-5.6d-45)) then
tmp = t_1
else if (b <= (-7.8d-56)) then
tmp = -b / a
else if (b <= (-6.5d-88)) then
tmp = t_1
else if (b <= (-1.75d-135)) then
tmp = t_0
else if (b <= 3.2d-136) then
tmp = t_1
else if (b <= 1d-76) then
tmp = 1.0d0 / ((a / b) - (b / c))
else if (b <= 1.08d-10) then
tmp = t_1
else
tmp = -c / b
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = (c / b) - (b / a);
double t_1 = (b - Math.sqrt((c * (a * -4.0)))) * (-0.5 / a);
double tmp;
if (b <= -1.08e-26) {
tmp = t_0;
} else if (b <= -5.6e-45) {
tmp = t_1;
} else if (b <= -7.8e-56) {
tmp = -b / a;
} else if (b <= -6.5e-88) {
tmp = t_1;
} else if (b <= -1.75e-135) {
tmp = t_0;
} else if (b <= 3.2e-136) {
tmp = t_1;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_1;
} else {
tmp = -c / b;
}
return tmp;
}
def code(a, b, c): t_0 = (c / b) - (b / a) t_1 = (b - math.sqrt((c * (a * -4.0)))) * (-0.5 / a) tmp = 0 if b <= -1.08e-26: tmp = t_0 elif b <= -5.6e-45: tmp = t_1 elif b <= -7.8e-56: tmp = -b / a elif b <= -6.5e-88: tmp = t_1 elif b <= -1.75e-135: tmp = t_0 elif b <= 3.2e-136: tmp = t_1 elif b <= 1e-76: tmp = 1.0 / ((a / b) - (b / c)) elif b <= 1.08e-10: tmp = t_1 else: tmp = -c / b return tmp
function code(a, b, c) t_0 = Float64(Float64(c / b) - Float64(b / a)) t_1 = Float64(Float64(b - sqrt(Float64(c * Float64(a * -4.0)))) * Float64(-0.5 / a)) tmp = 0.0 if (b <= -1.08e-26) tmp = t_0; elseif (b <= -5.6e-45) tmp = t_1; elseif (b <= -7.8e-56) tmp = Float64(Float64(-b) / a); elseif (b <= -6.5e-88) tmp = t_1; elseif (b <= -1.75e-135) tmp = t_0; elseif (b <= 3.2e-136) tmp = t_1; elseif (b <= 1e-76) tmp = Float64(1.0 / Float64(Float64(a / b) - Float64(b / c))); elseif (b <= 1.08e-10) tmp = t_1; else tmp = Float64(Float64(-c) / b); end return tmp end
function tmp_2 = code(a, b, c) t_0 = (c / b) - (b / a); t_1 = (b - sqrt((c * (a * -4.0)))) * (-0.5 / a); tmp = 0.0; if (b <= -1.08e-26) tmp = t_0; elseif (b <= -5.6e-45) tmp = t_1; elseif (b <= -7.8e-56) tmp = -b / a; elseif (b <= -6.5e-88) tmp = t_1; elseif (b <= -1.75e-135) tmp = t_0; elseif (b <= 3.2e-136) tmp = t_1; elseif (b <= 1e-76) tmp = 1.0 / ((a / b) - (b / c)); elseif (b <= 1.08e-10) tmp = t_1; else tmp = -c / b; end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(b - N[Sqrt[N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(-0.5 / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.08e-26], t$95$0, If[LessEqual[b, -5.6e-45], t$95$1, If[LessEqual[b, -7.8e-56], N[((-b) / a), $MachinePrecision], If[LessEqual[b, -6.5e-88], t$95$1, If[LessEqual[b, -1.75e-135], t$95$0, If[LessEqual[b, 3.2e-136], t$95$1, If[LessEqual[b, 1e-76], N[(1.0 / N[(N[(a / b), $MachinePrecision] - N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.08e-10], t$95$1, N[((-c) / b), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c}{b} - \frac{b}{a}\\
t_1 := \left(b - \sqrt{c \cdot \left(a \cdot -4\right)}\right) \cdot \frac{-0.5}{a}\\
\mathbf{if}\;b \leq -1.08 \cdot 10^{-26}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;b \leq -5.6 \cdot 10^{-45}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -7.8 \cdot 10^{-56}:\\
\;\;\;\;\frac{-b}{a}\\
\mathbf{elif}\;b \leq -6.5 \cdot 10^{-88}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -1.75 \cdot 10^{-135}:\\
\;\;\;\;t_0\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{-136}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 10^{-76}:\\
\;\;\;\;\frac{1}{\frac{a}{b} - \frac{b}{c}}\\
\mathbf{elif}\;b \leq 1.08 \cdot 10^{-10}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b}\\
\end{array}
\end{array}
if b < -1.07999999999999996e-26 or -6.50000000000000006e-88 < b < -1.7499999999999999e-135Initial program 68.7%
neg-sub068.7%
associate-+l-68.7%
sub0-neg68.7%
neg-mul-168.7%
associate-*l/68.6%
*-commutative68.6%
associate-/r*68.6%
/-rgt-identity68.6%
metadata-eval68.6%
Simplified68.6%
Taylor expanded in b around -inf 84.8%
mul-1-neg84.8%
unsub-neg84.8%
Simplified84.8%
if -1.07999999999999996e-26 < b < -5.6000000000000003e-45 or -7.8e-56 < b < -6.50000000000000006e-88 or -1.7499999999999999e-135 < b < 3.19999999999999993e-136 or 9.99999999999999927e-77 < b < 1.08000000000000002e-10Initial program 86.3%
neg-sub086.3%
associate-+l-86.3%
sub0-neg86.3%
neg-mul-186.3%
associate-*l/86.2%
*-commutative86.2%
associate-/r*86.2%
/-rgt-identity86.2%
metadata-eval86.2%
Simplified86.2%
Taylor expanded in a around inf 82.0%
*-commutative82.0%
associate-*r*82.0%
Simplified82.0%
if -5.6000000000000003e-45 < b < -7.8e-56Initial program 100.0%
neg-sub0100.0%
associate-+l-100.0%
sub0-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
*-commutative100.0%
associate-/r*100.0%
/-rgt-identity100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in b around -inf 100.0%
associate-*r/100.0%
neg-mul-1100.0%
Simplified100.0%
if 3.19999999999999993e-136 < b < 9.99999999999999927e-77Initial program 39.1%
clear-num38.9%
inv-pow38.9%
*-commutative38.9%
neg-mul-138.9%
fma-def38.9%
*-commutative38.9%
*-commutative38.9%
Applied egg-rr38.9%
unpow-138.9%
associate-/l*38.9%
Applied egg-rr38.9%
Taylor expanded in b around inf 52.9%
neg-mul-152.9%
sub-neg52.9%
Simplified52.9%
if 1.08000000000000002e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 95.5%
associate-*r/95.5%
neg-mul-195.5%
Simplified95.5%
Final simplification85.1%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (* c (* a -4.0))))
(t_1 (- (/ c b) (/ b a)))
(t_2 (* (- b t_0) (/ -0.5 a)))
(t_3 (/ (* 0.5 (- t_0 b)) a)))
(if (<= b -2.45e-27)
t_1
(if (<= b -1.25e-45)
t_2
(if (<= b -2.1e-53)
(/ (- b) a)
(if (<= b -2.9e-88)
t_3
(if (<= b -1.75e-135)
t_1
(if (<= b 3.4e-137)
t_3
(if (<= b 1e-76)
(/ 1.0 (- (/ a b) (/ b c)))
(if (<= b 1.08e-10) t_2 (/ (- c) b)))))))))))
double code(double a, double b, double c) {
double t_0 = sqrt((c * (a * -4.0)));
double t_1 = (c / b) - (b / a);
double t_2 = (b - t_0) * (-0.5 / a);
double t_3 = (0.5 * (t_0 - b)) / a;
double tmp;
if (b <= -2.45e-27) {
tmp = t_1;
} else if (b <= -1.25e-45) {
tmp = t_2;
} else if (b <= -2.1e-53) {
tmp = -b / a;
} else if (b <= -2.9e-88) {
tmp = t_3;
} else if (b <= -1.75e-135) {
tmp = t_1;
} else if (b <= 3.4e-137) {
tmp = t_3;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_2;
} else {
tmp = -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) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_0 = sqrt((c * (a * (-4.0d0))))
t_1 = (c / b) - (b / a)
t_2 = (b - t_0) * ((-0.5d0) / a)
t_3 = (0.5d0 * (t_0 - b)) / a
if (b <= (-2.45d-27)) then
tmp = t_1
else if (b <= (-1.25d-45)) then
tmp = t_2
else if (b <= (-2.1d-53)) then
tmp = -b / a
else if (b <= (-2.9d-88)) then
tmp = t_3
else if (b <= (-1.75d-135)) then
tmp = t_1
else if (b <= 3.4d-137) then
tmp = t_3
else if (b <= 1d-76) then
tmp = 1.0d0 / ((a / b) - (b / c))
else if (b <= 1.08d-10) then
tmp = t_2
else
tmp = -c / b
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt((c * (a * -4.0)));
double t_1 = (c / b) - (b / a);
double t_2 = (b - t_0) * (-0.5 / a);
double t_3 = (0.5 * (t_0 - b)) / a;
double tmp;
if (b <= -2.45e-27) {
tmp = t_1;
} else if (b <= -1.25e-45) {
tmp = t_2;
} else if (b <= -2.1e-53) {
tmp = -b / a;
} else if (b <= -2.9e-88) {
tmp = t_3;
} else if (b <= -1.75e-135) {
tmp = t_1;
} else if (b <= 3.4e-137) {
tmp = t_3;
} else if (b <= 1e-76) {
tmp = 1.0 / ((a / b) - (b / c));
} else if (b <= 1.08e-10) {
tmp = t_2;
} else {
tmp = -c / b;
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt((c * (a * -4.0))) t_1 = (c / b) - (b / a) t_2 = (b - t_0) * (-0.5 / a) t_3 = (0.5 * (t_0 - b)) / a tmp = 0 if b <= -2.45e-27: tmp = t_1 elif b <= -1.25e-45: tmp = t_2 elif b <= -2.1e-53: tmp = -b / a elif b <= -2.9e-88: tmp = t_3 elif b <= -1.75e-135: tmp = t_1 elif b <= 3.4e-137: tmp = t_3 elif b <= 1e-76: tmp = 1.0 / ((a / b) - (b / c)) elif b <= 1.08e-10: tmp = t_2 else: tmp = -c / b return tmp
function code(a, b, c) t_0 = sqrt(Float64(c * Float64(a * -4.0))) t_1 = Float64(Float64(c / b) - Float64(b / a)) t_2 = Float64(Float64(b - t_0) * Float64(-0.5 / a)) t_3 = Float64(Float64(0.5 * Float64(t_0 - b)) / a) tmp = 0.0 if (b <= -2.45e-27) tmp = t_1; elseif (b <= -1.25e-45) tmp = t_2; elseif (b <= -2.1e-53) tmp = Float64(Float64(-b) / a); elseif (b <= -2.9e-88) tmp = t_3; elseif (b <= -1.75e-135) tmp = t_1; elseif (b <= 3.4e-137) tmp = t_3; elseif (b <= 1e-76) tmp = Float64(1.0 / Float64(Float64(a / b) - Float64(b / c))); elseif (b <= 1.08e-10) tmp = t_2; else tmp = Float64(Float64(-c) / b); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt((c * (a * -4.0))); t_1 = (c / b) - (b / a); t_2 = (b - t_0) * (-0.5 / a); t_3 = (0.5 * (t_0 - b)) / a; tmp = 0.0; if (b <= -2.45e-27) tmp = t_1; elseif (b <= -1.25e-45) tmp = t_2; elseif (b <= -2.1e-53) tmp = -b / a; elseif (b <= -2.9e-88) tmp = t_3; elseif (b <= -1.75e-135) tmp = t_1; elseif (b <= 3.4e-137) tmp = t_3; elseif (b <= 1e-76) tmp = 1.0 / ((a / b) - (b / c)); elseif (b <= 1.08e-10) tmp = t_2; else tmp = -c / b; end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(b - t$95$0), $MachinePrecision] * N[(-0.5 / a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(0.5 * N[(t$95$0 - b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[b, -2.45e-27], t$95$1, If[LessEqual[b, -1.25e-45], t$95$2, If[LessEqual[b, -2.1e-53], N[((-b) / a), $MachinePrecision], If[LessEqual[b, -2.9e-88], t$95$3, If[LessEqual[b, -1.75e-135], t$95$1, If[LessEqual[b, 3.4e-137], t$95$3, If[LessEqual[b, 1e-76], N[(1.0 / N[(N[(a / b), $MachinePrecision] - N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.08e-10], t$95$2, N[((-c) / b), $MachinePrecision]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{c \cdot \left(a \cdot -4\right)}\\
t_1 := \frac{c}{b} - \frac{b}{a}\\
t_2 := \left(b - t_0\right) \cdot \frac{-0.5}{a}\\
t_3 := \frac{0.5 \cdot \left(t_0 - b\right)}{a}\\
\mathbf{if}\;b \leq -2.45 \cdot 10^{-27}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -1.25 \cdot 10^{-45}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq -2.1 \cdot 10^{-53}:\\
\;\;\;\;\frac{-b}{a}\\
\mathbf{elif}\;b \leq -2.9 \cdot 10^{-88}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq -1.75 \cdot 10^{-135}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 3.4 \cdot 10^{-137}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;b \leq 10^{-76}:\\
\;\;\;\;\frac{1}{\frac{a}{b} - \frac{b}{c}}\\
\mathbf{elif}\;b \leq 1.08 \cdot 10^{-10}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b}\\
\end{array}
\end{array}
if b < -2.44999999999999988e-27 or -2.9000000000000001e-88 < b < -1.7499999999999999e-135Initial program 68.7%
neg-sub068.7%
associate-+l-68.7%
sub0-neg68.7%
neg-mul-168.7%
associate-*l/68.6%
*-commutative68.6%
associate-/r*68.6%
/-rgt-identity68.6%
metadata-eval68.6%
Simplified68.6%
Taylor expanded in b around -inf 84.8%
mul-1-neg84.8%
unsub-neg84.8%
Simplified84.8%
if -2.44999999999999988e-27 < b < -1.24999999999999994e-45 or 9.99999999999999927e-77 < b < 1.08000000000000002e-10Initial program 94.4%
neg-sub094.4%
associate-+l-94.4%
sub0-neg94.4%
neg-mul-194.4%
associate-*l/94.5%
*-commutative94.5%
associate-/r*94.5%
/-rgt-identity94.5%
metadata-eval94.5%
Simplified94.5%
Taylor expanded in a around inf 89.5%
*-commutative89.5%
associate-*r*89.5%
Simplified89.5%
if -1.24999999999999994e-45 < b < -2.09999999999999977e-53Initial program 100.0%
neg-sub0100.0%
associate-+l-100.0%
sub0-neg100.0%
neg-mul-1100.0%
associate-*l/100.0%
*-commutative100.0%
associate-/r*100.0%
/-rgt-identity100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in b around -inf 100.0%
associate-*r/100.0%
neg-mul-1100.0%
Simplified100.0%
if -2.09999999999999977e-53 < b < -2.9000000000000001e-88 or -1.7499999999999999e-135 < b < 3.40000000000000014e-137Initial program 83.2%
/-rgt-identity83.2%
metadata-eval83.2%
associate-/l*83.2%
associate-*r/83.1%
+-commutative83.1%
unsub-neg83.1%
fma-neg83.1%
associate-*l*83.1%
*-commutative83.1%
distribute-rgt-neg-in83.1%
metadata-eval83.1%
associate-/r*83.1%
metadata-eval83.1%
metadata-eval83.1%
Simplified83.1%
fma-udef83.1%
associate-*l*83.1%
Applied egg-rr83.1%
Taylor expanded in b around 0 79.2%
*-commutative79.2%
associate-*r*79.2%
Simplified79.2%
associate-*r/79.3%
Applied egg-rr79.3%
if 3.40000000000000014e-137 < b < 9.99999999999999927e-77Initial program 39.1%
clear-num38.9%
inv-pow38.9%
*-commutative38.9%
neg-mul-138.9%
fma-def38.9%
*-commutative38.9%
*-commutative38.9%
Applied egg-rr38.9%
unpow-138.9%
associate-/l*38.9%
Applied egg-rr38.9%
Taylor expanded in b around inf 52.9%
neg-mul-152.9%
sub-neg52.9%
Simplified52.9%
if 1.08000000000000002e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 95.5%
associate-*r/95.5%
neg-mul-195.5%
Simplified95.5%
Final simplification85.1%
(FPCore (a b c)
:precision binary64
(if (<= b -2.1e+122)
(- (/ c b) (/ b a))
(if (<= b 2e-10)
(* (- (sqrt (+ (* b b) (* a (* c -4.0)))) b) (/ 0.5 a))
(- (/ (- c) b) (/ c (/ (/ (pow b 3.0) a) c))))))
double code(double a, double b, double c) {
double tmp;
if (b <= -2.1e+122) {
tmp = (c / b) - (b / a);
} else if (b <= 2e-10) {
tmp = (sqrt(((b * b) + (a * (c * -4.0)))) - b) * (0.5 / a);
} else {
tmp = (-c / b) - (c / ((pow(b, 3.0) / a) / c));
}
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 <= (-2.1d+122)) then
tmp = (c / b) - (b / a)
else if (b <= 2d-10) then
tmp = (sqrt(((b * b) + (a * (c * (-4.0d0))))) - b) * (0.5d0 / a)
else
tmp = (-c / b) - (c / (((b ** 3.0d0) / a) / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -2.1e+122) {
tmp = (c / b) - (b / a);
} else if (b <= 2e-10) {
tmp = (Math.sqrt(((b * b) + (a * (c * -4.0)))) - b) * (0.5 / a);
} else {
tmp = (-c / b) - (c / ((Math.pow(b, 3.0) / a) / c));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -2.1e+122: tmp = (c / b) - (b / a) elif b <= 2e-10: tmp = (math.sqrt(((b * b) + (a * (c * -4.0)))) - b) * (0.5 / a) else: tmp = (-c / b) - (c / ((math.pow(b, 3.0) / a) / c)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -2.1e+122) tmp = Float64(Float64(c / b) - Float64(b / a)); elseif (b <= 2e-10) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) + Float64(a * Float64(c * -4.0)))) - b) * Float64(0.5 / a)); else tmp = Float64(Float64(Float64(-c) / b) - Float64(c / Float64(Float64((b ^ 3.0) / a) / c))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -2.1e+122) tmp = (c / b) - (b / a); elseif (b <= 2e-10) tmp = (sqrt(((b * b) + (a * (c * -4.0)))) - b) * (0.5 / a); else tmp = (-c / b) - (c / (((b ^ 3.0) / a) / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -2.1e+122], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e-10], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] * N[(0.5 / a), $MachinePrecision]), $MachinePrecision], N[(N[((-c) / b), $MachinePrecision] - N[(c / N[(N[(N[Power[b, 3.0], $MachinePrecision] / a), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.1 \cdot 10^{+122}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\left(\sqrt{b \cdot b + a \cdot \left(c \cdot -4\right)} - b\right) \cdot \frac{0.5}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b} - \frac{c}{\frac{\frac{{b}^{3}}{a}}{c}}\\
\end{array}
\end{array}
if b < -2.10000000000000016e122Initial program 46.9%
neg-sub046.9%
associate-+l-46.9%
sub0-neg46.9%
neg-mul-146.9%
associate-*l/46.9%
*-commutative46.9%
associate-/r*46.9%
/-rgt-identity46.9%
metadata-eval46.9%
Simplified47.0%
Taylor expanded in b around -inf 93.9%
mul-1-neg93.9%
unsub-neg93.9%
Simplified93.9%
if -2.10000000000000016e122 < b < 2.00000000000000007e-10Initial program 81.8%
/-rgt-identity81.8%
metadata-eval81.8%
associate-/l*81.8%
associate-*r/81.7%
+-commutative81.7%
unsub-neg81.7%
fma-neg81.7%
associate-*l*81.7%
*-commutative81.7%
distribute-rgt-neg-in81.7%
metadata-eval81.7%
associate-/r*81.7%
metadata-eval81.7%
metadata-eval81.7%
Simplified81.7%
fma-udef81.7%
associate-*l*81.7%
Applied egg-rr81.7%
if 2.00000000000000007e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 83.0%
+-commutative83.0%
mul-1-neg83.0%
unsub-neg83.0%
associate-*r/83.0%
neg-mul-183.0%
associate-/l*84.4%
unpow284.4%
associate-/l*95.9%
Simplified95.9%
Final simplification87.7%
(FPCore (a b c)
:precision binary64
(if (<= b -3e+123)
(- (/ c b) (/ b a))
(if (<= b 1.25e-10)
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* a 2.0))
(- (/ (- c) b) (/ c (/ (/ (pow b 3.0) a) c))))))
double code(double a, double b, double c) {
double tmp;
if (b <= -3e+123) {
tmp = (c / b) - (b / a);
} else if (b <= 1.25e-10) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (a * 2.0);
} else {
tmp = (-c / b) - (c / ((pow(b, 3.0) / a) / c));
}
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 <= (-3d+123)) then
tmp = (c / b) - (b / a)
else if (b <= 1.25d-10) then
tmp = (sqrt(((b * b) - (c * (a * 4.0d0)))) - b) / (a * 2.0d0)
else
tmp = (-c / b) - (c / (((b ** 3.0d0) / a) / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -3e+123) {
tmp = (c / b) - (b / a);
} else if (b <= 1.25e-10) {
tmp = (Math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (a * 2.0);
} else {
tmp = (-c / b) - (c / ((Math.pow(b, 3.0) / a) / c));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -3e+123: tmp = (c / b) - (b / a) elif b <= 1.25e-10: tmp = (math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (a * 2.0) else: tmp = (-c / b) - (c / ((math.pow(b, 3.0) / a) / c)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -3e+123) tmp = Float64(Float64(c / b) - Float64(b / a)); elseif (b <= 1.25e-10) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(a * 2.0)); else tmp = Float64(Float64(Float64(-c) / b) - Float64(c / Float64(Float64((b ^ 3.0) / a) / c))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -3e+123) tmp = (c / b) - (b / a); elseif (b <= 1.25e-10) tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (a * 2.0); else tmp = (-c / b) - (c / (((b ^ 3.0) / a) / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -3e+123], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.25e-10], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(a * 2.0), $MachinePrecision]), $MachinePrecision], N[(N[((-c) / b), $MachinePrecision] - N[(c / N[(N[(N[Power[b, 3.0], $MachinePrecision] / a), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3 \cdot 10^{+123}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{elif}\;b \leq 1.25 \cdot 10^{-10}:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{a \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b} - \frac{c}{\frac{\frac{{b}^{3}}{a}}{c}}\\
\end{array}
\end{array}
if b < -3.00000000000000008e123Initial program 46.9%
neg-sub046.9%
associate-+l-46.9%
sub0-neg46.9%
neg-mul-146.9%
associate-*l/46.9%
*-commutative46.9%
associate-/r*46.9%
/-rgt-identity46.9%
metadata-eval46.9%
Simplified47.0%
Taylor expanded in b around -inf 93.9%
mul-1-neg93.9%
unsub-neg93.9%
Simplified93.9%
if -3.00000000000000008e123 < b < 1.25000000000000008e-10Initial program 81.8%
if 1.25000000000000008e-10 < b Initial program 18.8%
neg-sub018.8%
associate-+l-18.8%
sub0-neg18.8%
neg-mul-118.8%
associate-*l/18.8%
*-commutative18.8%
associate-/r*18.8%
/-rgt-identity18.8%
metadata-eval18.8%
Simplified18.8%
Taylor expanded in b around inf 83.0%
+-commutative83.0%
mul-1-neg83.0%
unsub-neg83.0%
associate-*r/83.0%
neg-mul-183.0%
associate-/l*84.4%
unpow284.4%
associate-/l*95.9%
Simplified95.9%
Final simplification87.8%
(FPCore (a b c) :precision binary64 (if (<= b -8e-304) (- (/ c b) (/ b a)) (/ 1.0 (- (/ a b) (/ b c)))))
double code(double a, double b, double c) {
double tmp;
if (b <= -8e-304) {
tmp = (c / b) - (b / a);
} else {
tmp = 1.0 / ((a / b) - (b / c));
}
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 <= (-8d-304)) then
tmp = (c / b) - (b / a)
else
tmp = 1.0d0 / ((a / b) - (b / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -8e-304) {
tmp = (c / b) - (b / a);
} else {
tmp = 1.0 / ((a / b) - (b / c));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -8e-304: tmp = (c / b) - (b / a) else: tmp = 1.0 / ((a / b) - (b / c)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -8e-304) tmp = Float64(Float64(c / b) - Float64(b / a)); else tmp = Float64(1.0 / Float64(Float64(a / b) - Float64(b / c))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -8e-304) tmp = (c / b) - (b / a); else tmp = 1.0 / ((a / b) - (b / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -8e-304], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(a / b), $MachinePrecision] - N[(b / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8 \cdot 10^{-304}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{a}{b} - \frac{b}{c}}\\
\end{array}
\end{array}
if b < -7.99999999999999977e-304Initial program 73.0%
neg-sub073.0%
associate-+l-73.0%
sub0-neg73.0%
neg-mul-173.0%
associate-*l/72.9%
*-commutative72.9%
associate-/r*72.9%
/-rgt-identity72.9%
metadata-eval72.9%
Simplified72.9%
Taylor expanded in b around -inf 67.1%
mul-1-neg67.1%
unsub-neg67.1%
Simplified67.1%
if -7.99999999999999977e-304 < b Initial program 42.7%
clear-num42.7%
inv-pow42.7%
*-commutative42.7%
neg-mul-142.7%
fma-def42.7%
*-commutative42.7%
*-commutative42.7%
Applied egg-rr42.7%
unpow-142.7%
associate-/l*42.7%
Applied egg-rr42.7%
Taylor expanded in b around inf 64.7%
neg-mul-164.7%
sub-neg64.7%
Simplified64.7%
Final simplification66.0%
(FPCore (a b c) :precision binary64 (if (<= b -1e-309) (- (/ c b) (/ b a)) (/ (- c) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= -1e-309) {
tmp = (c / b) - (b / a);
} else {
tmp = -c / b;
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-1d-309)) then
tmp = (c / b) - (b / a)
else
tmp = -c / b
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -1e-309) {
tmp = (c / b) - (b / a);
} else {
tmp = -c / b;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -1e-309: tmp = (c / b) - (b / a) else: tmp = -c / b return tmp
function code(a, b, c) tmp = 0.0 if (b <= -1e-309) tmp = Float64(Float64(c / b) - Float64(b / a)); else tmp = Float64(Float64(-c) / b); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -1e-309) tmp = (c / b) - (b / a); else tmp = -c / b; end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -1e-309], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision], N[((-c) / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1 \cdot 10^{-309}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b}\\
\end{array}
\end{array}
if b < -1.000000000000002e-309Initial program 73.4%
neg-sub073.4%
associate-+l-73.4%
sub0-neg73.4%
neg-mul-173.4%
associate-*l/73.3%
*-commutative73.3%
associate-/r*73.3%
/-rgt-identity73.3%
metadata-eval73.3%
Simplified73.3%
Taylor expanded in b around -inf 66.2%
mul-1-neg66.2%
unsub-neg66.2%
Simplified66.2%
if -1.000000000000002e-309 < b Initial program 41.8%
neg-sub041.8%
associate-+l-41.8%
sub0-neg41.8%
neg-mul-141.8%
associate-*l/41.7%
*-commutative41.7%
associate-/r*41.7%
/-rgt-identity41.7%
metadata-eval41.7%
Simplified41.7%
Taylor expanded in b around inf 65.7%
associate-*r/65.7%
neg-mul-165.7%
Simplified65.7%
Final simplification65.9%
(FPCore (a b c) :precision binary64 (if (<= b -1e-309) (/ (- b) a) (/ 0.0 a)))
double code(double a, double b, double c) {
double tmp;
if (b <= -1e-309) {
tmp = -b / a;
} else {
tmp = 0.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) :: tmp
if (b <= (-1d-309)) then
tmp = -b / a
else
tmp = 0.0d0 / a
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -1e-309) {
tmp = -b / a;
} else {
tmp = 0.0 / a;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -1e-309: tmp = -b / a else: tmp = 0.0 / a return tmp
function code(a, b, c) tmp = 0.0 if (b <= -1e-309) tmp = Float64(Float64(-b) / a); else tmp = Float64(0.0 / a); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -1e-309) tmp = -b / a; else tmp = 0.0 / a; end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -1e-309], N[((-b) / a), $MachinePrecision], N[(0.0 / a), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1 \cdot 10^{-309}:\\
\;\;\;\;\frac{-b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{0}{a}\\
\end{array}
\end{array}
if b < -1.000000000000002e-309Initial program 73.4%
neg-sub073.4%
associate-+l-73.4%
sub0-neg73.4%
neg-mul-173.4%
associate-*l/73.3%
*-commutative73.3%
associate-/r*73.3%
/-rgt-identity73.3%
metadata-eval73.3%
Simplified73.3%
Taylor expanded in b around -inf 65.7%
associate-*r/65.7%
neg-mul-165.7%
Simplified65.7%
if -1.000000000000002e-309 < b Initial program 41.8%
clear-num41.7%
inv-pow41.7%
*-commutative41.7%
neg-mul-141.7%
fma-def41.7%
*-commutative41.7%
*-commutative41.7%
Applied egg-rr41.7%
Taylor expanded in a around 0 24.6%
associate-*r/24.6%
distribute-rgt1-in24.6%
metadata-eval24.6%
mul0-lft24.6%
metadata-eval24.6%
Simplified24.6%
Final simplification45.9%
(FPCore (a b c) :precision binary64 (if (<= b 2.5e-286) (/ (- b) a) (/ (- c) b)))
double code(double a, double b, double c) {
double tmp;
if (b <= 2.5e-286) {
tmp = -b / a;
} else {
tmp = -c / b;
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= 2.5d-286) then
tmp = -b / a
else
tmp = -c / b
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 2.5e-286) {
tmp = -b / a;
} else {
tmp = -c / b;
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 2.5e-286: tmp = -b / a else: tmp = -c / b return tmp
function code(a, b, c) tmp = 0.0 if (b <= 2.5e-286) tmp = Float64(Float64(-b) / a); else tmp = Float64(Float64(-c) / b); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 2.5e-286) tmp = -b / a; else tmp = -c / b; end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 2.5e-286], N[((-b) / a), $MachinePrecision], N[((-c) / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.5 \cdot 10^{-286}:\\
\;\;\;\;\frac{-b}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{-c}{b}\\
\end{array}
\end{array}
if b < 2.50000000000000018e-286Initial program 73.8%
neg-sub073.8%
associate-+l-73.8%
sub0-neg73.8%
neg-mul-173.8%
associate-*l/73.7%
*-commutative73.7%
associate-/r*73.7%
/-rgt-identity73.7%
metadata-eval73.7%
Simplified73.7%
Taylor expanded in b around -inf 64.7%
associate-*r/64.7%
neg-mul-164.7%
Simplified64.7%
if 2.50000000000000018e-286 < b Initial program 40.8%
neg-sub040.8%
associate-+l-40.8%
sub0-neg40.8%
neg-mul-140.8%
associate-*l/40.7%
*-commutative40.7%
associate-/r*40.7%
/-rgt-identity40.7%
metadata-eval40.7%
Simplified40.7%
Taylor expanded in b around inf 66.7%
associate-*r/66.7%
neg-mul-166.7%
Simplified66.7%
Final simplification65.7%
(FPCore (a b c) :precision binary64 (/ 0.0 a))
double code(double a, double b, double c) {
return 0.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 = 0.0d0 / a
end function
public static double code(double a, double b, double c) {
return 0.0 / a;
}
def code(a, b, c): return 0.0 / a
function code(a, b, c) return Float64(0.0 / a) end
function tmp = code(a, b, c) tmp = 0.0 / a; end
code[a_, b_, c_] := N[(0.0 / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{0}{a}
\end{array}
Initial program 58.2%
clear-num58.1%
inv-pow58.1%
*-commutative58.1%
neg-mul-158.1%
fma-def58.1%
*-commutative58.1%
*-commutative58.1%
Applied egg-rr58.1%
Taylor expanded in a around 0 13.3%
associate-*r/13.3%
distribute-rgt1-in13.3%
metadata-eval13.3%
mul0-lft13.3%
metadata-eval13.3%
Simplified13.3%
Final simplification13.3%
herbie shell --seed 2023193
(FPCore (a b c)
:name "Quadratic roots, full range"
:precision binary64
(/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))