
(FPCore (a b_2 c) :precision binary64 (/ (+ (- b_2) (sqrt (- (* b_2 b_2) (* a c)))) a))
double code(double a, double b_2, double c) {
return (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
code = (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a
end function
public static double code(double a, double b_2, double c) {
return (-b_2 + Math.sqrt(((b_2 * b_2) - (a * c)))) / a;
}
def code(a, b_2, c): return (-b_2 + math.sqrt(((b_2 * b_2) - (a * c)))) / a
function code(a, b_2, c) return Float64(Float64(Float64(-b_2) + sqrt(Float64(Float64(b_2 * b_2) - Float64(a * c)))) / a) end
function tmp = code(a, b_2, c) tmp = (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a; end
code[a_, b$95$2_, c_] := N[(N[((-b$95$2) + N[Sqrt[N[(N[(b$95$2 * b$95$2), $MachinePrecision] - N[(a * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b_2\right) + \sqrt{b_2 \cdot b_2 - a \cdot c}}{a}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b_2 c) :precision binary64 (/ (+ (- b_2) (sqrt (- (* b_2 b_2) (* a c)))) a))
double code(double a, double b_2, double c) {
return (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
code = (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a
end function
public static double code(double a, double b_2, double c) {
return (-b_2 + Math.sqrt(((b_2 * b_2) - (a * c)))) / a;
}
def code(a, b_2, c): return (-b_2 + math.sqrt(((b_2 * b_2) - (a * c)))) / a
function code(a, b_2, c) return Float64(Float64(Float64(-b_2) + sqrt(Float64(Float64(b_2 * b_2) - Float64(a * c)))) / a) end
function tmp = code(a, b_2, c) tmp = (-b_2 + sqrt(((b_2 * b_2) - (a * c)))) / a; end
code[a_, b$95$2_, c_] := N[(N[((-b$95$2) + N[Sqrt[N[(N[(b$95$2 * b$95$2), $MachinePrecision] - N[(a * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b_2\right) + \sqrt{b_2 \cdot b_2 - a \cdot c}}{a}
\end{array}
(FPCore (a b_2 c)
:precision binary64
(if (<= b_2 -3.6e+108)
(/ (* b_2 -2.0) a)
(if (<= b_2 5.1e-54)
(/ (- (sqrt (- (* b_2 b_2) (* a c))) b_2) a)
(/ 1.0 (+ (* 0.5 (/ a b_2)) (* -2.0 (/ b_2 c)))))))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -3.6e+108) {
tmp = (b_2 * -2.0) / a;
} else if (b_2 <= 5.1e-54) {
tmp = (sqrt(((b_2 * b_2) - (a * c))) - b_2) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-3.6d+108)) then
tmp = (b_2 * (-2.0d0)) / a
else if (b_2 <= 5.1d-54) then
tmp = (sqrt(((b_2 * b_2) - (a * c))) - b_2) / a
else
tmp = 1.0d0 / ((0.5d0 * (a / b_2)) + ((-2.0d0) * (b_2 / c)))
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -3.6e+108) {
tmp = (b_2 * -2.0) / a;
} else if (b_2 <= 5.1e-54) {
tmp = (Math.sqrt(((b_2 * b_2) - (a * c))) - b_2) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -3.6e+108: tmp = (b_2 * -2.0) / a elif b_2 <= 5.1e-54: tmp = (math.sqrt(((b_2 * b_2) - (a * c))) - b_2) / a else: tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))) return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -3.6e+108) tmp = Float64(Float64(b_2 * -2.0) / a); elseif (b_2 <= 5.1e-54) tmp = Float64(Float64(sqrt(Float64(Float64(b_2 * b_2) - Float64(a * c))) - b_2) / a); else tmp = Float64(1.0 / Float64(Float64(0.5 * Float64(a / b_2)) + Float64(-2.0 * Float64(b_2 / c)))); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -3.6e+108) tmp = (b_2 * -2.0) / a; elseif (b_2 <= 5.1e-54) tmp = (sqrt(((b_2 * b_2) - (a * c))) - b_2) / a; else tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))); end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -3.6e+108], N[(N[(b$95$2 * -2.0), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[b$95$2, 5.1e-54], N[(N[(N[Sqrt[N[(N[(b$95$2 * b$95$2), $MachinePrecision] - N[(a * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b$95$2), $MachinePrecision] / a), $MachinePrecision], N[(1.0 / N[(N[(0.5 * N[(a / b$95$2), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(b$95$2 / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -3.6 \cdot 10^{+108}:\\
\;\;\;\;\frac{b_2 \cdot -2}{a}\\
\mathbf{elif}\;b_2 \leq 5.1 \cdot 10^{-54}:\\
\;\;\;\;\frac{\sqrt{b_2 \cdot b_2 - a \cdot c} - b_2}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{0.5 \cdot \frac{a}{b_2} + -2 \cdot \frac{b_2}{c}}\\
\end{array}
\end{array}
if b_2 < -3.6e108Initial program 47.0%
+-commutative47.0%
unsub-neg47.0%
Simplified47.0%
Taylor expanded in b_2 around -inf 94.9%
*-commutative94.9%
Simplified94.9%
if -3.6e108 < b_2 < 5.1000000000000001e-54Initial program 84.0%
+-commutative84.0%
unsub-neg84.0%
Simplified84.0%
if 5.1000000000000001e-54 < b_2 Initial program 13.5%
+-commutative13.5%
unsub-neg13.5%
Simplified13.5%
add-cbrt-cube7.3%
pow37.3%
pow1/36.5%
sqrt-pow26.5%
fma-neg6.6%
*-commutative6.6%
distribute-rgt-neg-in6.6%
metadata-eval6.6%
Applied egg-rr6.6%
unpow1/37.4%
distribute-rgt-neg-out7.4%
*-commutative7.4%
fma-neg7.3%
*-commutative7.3%
Simplified7.3%
clear-num7.3%
inv-pow7.3%
pow1/36.5%
pow-pow13.4%
*-commutative13.4%
metadata-eval13.4%
Applied egg-rr13.4%
unpow-113.4%
unpow1/213.4%
*-commutative13.4%
Simplified13.4%
Taylor expanded in a around 0 87.0%
Final simplification87.3%
(FPCore (a b_2 c)
:precision binary64
(if (<= b_2 -3.6e-51)
(+ (* -2.0 (/ b_2 a)) (* 0.5 (/ c b_2)))
(if (<= b_2 1.1e-55)
(/ (- (sqrt (* c (- a))) b_2) a)
(/ 1.0 (+ (* 0.5 (/ a b_2)) (* -2.0 (/ b_2 c)))))))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -3.6e-51) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else if (b_2 <= 1.1e-55) {
tmp = (sqrt((c * -a)) - b_2) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-3.6d-51)) then
tmp = ((-2.0d0) * (b_2 / a)) + (0.5d0 * (c / b_2))
else if (b_2 <= 1.1d-55) then
tmp = (sqrt((c * -a)) - b_2) / a
else
tmp = 1.0d0 / ((0.5d0 * (a / b_2)) + ((-2.0d0) * (b_2 / c)))
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -3.6e-51) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else if (b_2 <= 1.1e-55) {
tmp = (Math.sqrt((c * -a)) - b_2) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -3.6e-51: tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)) elif b_2 <= 1.1e-55: tmp = (math.sqrt((c * -a)) - b_2) / a else: tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))) return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -3.6e-51) tmp = Float64(Float64(-2.0 * Float64(b_2 / a)) + Float64(0.5 * Float64(c / b_2))); elseif (b_2 <= 1.1e-55) tmp = Float64(Float64(sqrt(Float64(c * Float64(-a))) - b_2) / a); else tmp = Float64(1.0 / Float64(Float64(0.5 * Float64(a / b_2)) + Float64(-2.0 * Float64(b_2 / c)))); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -3.6e-51) tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)); elseif (b_2 <= 1.1e-55) tmp = (sqrt((c * -a)) - b_2) / a; else tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))); end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -3.6e-51], N[(N[(-2.0 * N[(b$95$2 / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(c / b$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b$95$2, 1.1e-55], N[(N[(N[Sqrt[N[(c * (-a)), $MachinePrecision]], $MachinePrecision] - b$95$2), $MachinePrecision] / a), $MachinePrecision], N[(1.0 / N[(N[(0.5 * N[(a / b$95$2), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(b$95$2 / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -3.6 \cdot 10^{-51}:\\
\;\;\;\;-2 \cdot \frac{b_2}{a} + 0.5 \cdot \frac{c}{b_2}\\
\mathbf{elif}\;b_2 \leq 1.1 \cdot 10^{-55}:\\
\;\;\;\;\frac{\sqrt{c \cdot \left(-a\right)} - b_2}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{0.5 \cdot \frac{a}{b_2} + -2 \cdot \frac{b_2}{c}}\\
\end{array}
\end{array}
if b_2 < -3.6e-51Initial program 65.2%
+-commutative65.2%
unsub-neg65.2%
Simplified65.2%
Taylor expanded in b_2 around -inf 87.9%
if -3.6e-51 < b_2 < 1.1e-55Initial program 79.6%
+-commutative79.6%
unsub-neg79.6%
Simplified79.6%
Taylor expanded in b_2 around 0 74.3%
mul-1-neg74.3%
distribute-rgt-neg-out74.3%
Simplified74.3%
if 1.1e-55 < b_2 Initial program 13.5%
+-commutative13.5%
unsub-neg13.5%
Simplified13.5%
add-cbrt-cube7.3%
pow37.3%
pow1/36.5%
sqrt-pow26.5%
fma-neg6.6%
*-commutative6.6%
distribute-rgt-neg-in6.6%
metadata-eval6.6%
Applied egg-rr6.6%
unpow1/37.4%
distribute-rgt-neg-out7.4%
*-commutative7.4%
fma-neg7.3%
*-commutative7.3%
Simplified7.3%
clear-num7.3%
inv-pow7.3%
pow1/36.5%
pow-pow13.4%
*-commutative13.4%
metadata-eval13.4%
Applied egg-rr13.4%
unpow-113.4%
unpow1/213.4%
*-commutative13.4%
Simplified13.4%
Taylor expanded in a around 0 87.0%
Final simplification83.3%
(FPCore (a b_2 c)
:precision binary64
(if (<= b_2 -2.55e-61)
(+ (* -2.0 (/ b_2 a)) (* 0.5 (/ c b_2)))
(if (<= b_2 2.25e-57)
(/ (sqrt (* c (- a))) a)
(/ 1.0 (+ (* 0.5 (/ a b_2)) (* -2.0 (/ b_2 c)))))))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -2.55e-61) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else if (b_2 <= 2.25e-57) {
tmp = sqrt((c * -a)) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-2.55d-61)) then
tmp = ((-2.0d0) * (b_2 / a)) + (0.5d0 * (c / b_2))
else if (b_2 <= 2.25d-57) then
tmp = sqrt((c * -a)) / a
else
tmp = 1.0d0 / ((0.5d0 * (a / b_2)) + ((-2.0d0) * (b_2 / c)))
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -2.55e-61) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else if (b_2 <= 2.25e-57) {
tmp = Math.sqrt((c * -a)) / a;
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -2.55e-61: tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)) elif b_2 <= 2.25e-57: tmp = math.sqrt((c * -a)) / a else: tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))) return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -2.55e-61) tmp = Float64(Float64(-2.0 * Float64(b_2 / a)) + Float64(0.5 * Float64(c / b_2))); elseif (b_2 <= 2.25e-57) tmp = Float64(sqrt(Float64(c * Float64(-a))) / a); else tmp = Float64(1.0 / Float64(Float64(0.5 * Float64(a / b_2)) + Float64(-2.0 * Float64(b_2 / c)))); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -2.55e-61) tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)); elseif (b_2 <= 2.25e-57) tmp = sqrt((c * -a)) / a; else tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))); end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -2.55e-61], N[(N[(-2.0 * N[(b$95$2 / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(c / b$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b$95$2, 2.25e-57], N[(N[Sqrt[N[(c * (-a)), $MachinePrecision]], $MachinePrecision] / a), $MachinePrecision], N[(1.0 / N[(N[(0.5 * N[(a / b$95$2), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(b$95$2 / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -2.55 \cdot 10^{-61}:\\
\;\;\;\;-2 \cdot \frac{b_2}{a} + 0.5 \cdot \frac{c}{b_2}\\
\mathbf{elif}\;b_2 \leq 2.25 \cdot 10^{-57}:\\
\;\;\;\;\frac{\sqrt{c \cdot \left(-a\right)}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{0.5 \cdot \frac{a}{b_2} + -2 \cdot \frac{b_2}{c}}\\
\end{array}
\end{array}
if b_2 < -2.54999999999999984e-61Initial program 66.8%
+-commutative66.8%
unsub-neg66.8%
Simplified66.8%
Taylor expanded in b_2 around -inf 86.4%
if -2.54999999999999984e-61 < b_2 < 2.24999999999999986e-57Initial program 78.5%
+-commutative78.5%
unsub-neg78.5%
Simplified78.5%
prod-diff78.1%
*-commutative78.1%
fma-def78.1%
associate-+l+78.1%
distribute-rgt-neg-in78.1%
fma-def78.0%
*-commutative78.0%
fma-udef78.1%
distribute-lft-neg-in78.1%
*-commutative78.1%
distribute-rgt-neg-in78.1%
fma-def78.0%
Applied egg-rr78.0%
Taylor expanded in b_2 around 0 74.0%
associate-*l/74.1%
distribute-rgt1-in74.5%
metadata-eval74.5%
mul-1-neg74.5%
distribute-rgt-neg-out74.5%
*-lft-identity74.5%
Simplified74.5%
if 2.24999999999999986e-57 < b_2 Initial program 13.5%
+-commutative13.5%
unsub-neg13.5%
Simplified13.5%
add-cbrt-cube7.3%
pow37.3%
pow1/36.5%
sqrt-pow26.5%
fma-neg6.6%
*-commutative6.6%
distribute-rgt-neg-in6.6%
metadata-eval6.6%
Applied egg-rr6.6%
unpow1/37.4%
distribute-rgt-neg-out7.4%
*-commutative7.4%
fma-neg7.3%
*-commutative7.3%
Simplified7.3%
clear-num7.3%
inv-pow7.3%
pow1/36.5%
pow-pow13.4%
*-commutative13.4%
metadata-eval13.4%
Applied egg-rr13.4%
unpow-113.4%
unpow1/213.4%
*-commutative13.4%
Simplified13.4%
Taylor expanded in a around 0 87.0%
Final simplification83.1%
(FPCore (a b_2 c) :precision binary64 (if (<= b_2 -4.1e-284) (+ (* -2.0 (/ b_2 a)) (* 0.5 (/ c b_2))) (/ 1.0 (+ (* 0.5 (/ a b_2)) (* -2.0 (/ b_2 c))))))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -4.1e-284) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-4.1d-284)) then
tmp = ((-2.0d0) * (b_2 / a)) + (0.5d0 * (c / b_2))
else
tmp = 1.0d0 / ((0.5d0 * (a / b_2)) + ((-2.0d0) * (b_2 / c)))
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -4.1e-284) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else {
tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c)));
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -4.1e-284: tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)) else: tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))) return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -4.1e-284) tmp = Float64(Float64(-2.0 * Float64(b_2 / a)) + Float64(0.5 * Float64(c / b_2))); else tmp = Float64(1.0 / Float64(Float64(0.5 * Float64(a / b_2)) + Float64(-2.0 * Float64(b_2 / c)))); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -4.1e-284) tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)); else tmp = 1.0 / ((0.5 * (a / b_2)) + (-2.0 * (b_2 / c))); end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -4.1e-284], N[(N[(-2.0 * N[(b$95$2 / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(c / b$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(0.5 * N[(a / b$95$2), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * N[(b$95$2 / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -4.1 \cdot 10^{-284}:\\
\;\;\;\;-2 \cdot \frac{b_2}{a} + 0.5 \cdot \frac{c}{b_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{0.5 \cdot \frac{a}{b_2} + -2 \cdot \frac{b_2}{c}}\\
\end{array}
\end{array}
if b_2 < -4.09999999999999999e-284Initial program 71.0%
+-commutative71.0%
unsub-neg71.0%
Simplified71.0%
Taylor expanded in b_2 around -inf 65.7%
if -4.09999999999999999e-284 < b_2 Initial program 31.5%
+-commutative31.5%
unsub-neg31.5%
Simplified31.5%
add-cbrt-cube22.9%
pow322.9%
pow1/321.1%
sqrt-pow221.1%
fma-neg21.1%
*-commutative21.1%
distribute-rgt-neg-in21.1%
metadata-eval21.1%
Applied egg-rr21.1%
unpow1/323.0%
distribute-rgt-neg-out23.0%
*-commutative23.0%
fma-neg22.9%
*-commutative22.9%
Simplified22.9%
clear-num22.9%
inv-pow22.9%
pow1/321.1%
pow-pow31.4%
*-commutative31.4%
metadata-eval31.4%
Applied egg-rr31.4%
unpow-131.4%
unpow1/231.4%
*-commutative31.4%
Simplified31.4%
Taylor expanded in a around 0 63.8%
Final simplification64.8%
(FPCore (a b_2 c) :precision binary64 (if (<= b_2 -1e-309) (+ (* -2.0 (/ b_2 a)) (* 0.5 (/ c b_2))) (* (/ c b_2) -0.5)))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-1d-309)) then
tmp = ((-2.0d0) * (b_2 / a)) + (0.5d0 * (c / b_2))
else
tmp = (c / b_2) * (-0.5d0)
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2));
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -1e-309: tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)) else: tmp = (c / b_2) * -0.5 return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -1e-309) tmp = Float64(Float64(-2.0 * Float64(b_2 / a)) + Float64(0.5 * Float64(c / b_2))); else tmp = Float64(Float64(c / b_2) * -0.5); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -1e-309) tmp = (-2.0 * (b_2 / a)) + (0.5 * (c / b_2)); else tmp = (c / b_2) * -0.5; end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -1e-309], N[(N[(-2.0 * N[(b$95$2 / a), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(c / b$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(c / b$95$2), $MachinePrecision] * -0.5), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -1 \cdot 10^{-309}:\\
\;\;\;\;-2 \cdot \frac{b_2}{a} + 0.5 \cdot \frac{c}{b_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{c}{b_2} \cdot -0.5\\
\end{array}
\end{array}
if b_2 < -1.000000000000002e-309Initial program 71.6%
+-commutative71.6%
unsub-neg71.6%
Simplified71.6%
Taylor expanded in b_2 around -inf 64.3%
if -1.000000000000002e-309 < b_2 Initial program 29.8%
+-commutative29.8%
unsub-neg29.8%
Simplified29.8%
Taylor expanded in b_2 around inf 64.7%
Final simplification64.5%
(FPCore (a b_2 c) :precision binary64 (if (<= b_2 -1e-309) (/ (- b_2) a) (* (/ c b_2) -0.5)))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = -b_2 / a;
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-1d-309)) then
tmp = -b_2 / a
else
tmp = (c / b_2) * (-0.5d0)
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = -b_2 / a;
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -1e-309: tmp = -b_2 / a else: tmp = (c / b_2) * -0.5 return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -1e-309) tmp = Float64(Float64(-b_2) / a); else tmp = Float64(Float64(c / b_2) * -0.5); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -1e-309) tmp = -b_2 / a; else tmp = (c / b_2) * -0.5; end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -1e-309], N[((-b$95$2) / a), $MachinePrecision], N[(N[(c / b$95$2), $MachinePrecision] * -0.5), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -1 \cdot 10^{-309}:\\
\;\;\;\;\frac{-b_2}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c}{b_2} \cdot -0.5\\
\end{array}
\end{array}
if b_2 < -1.000000000000002e-309Initial program 71.6%
+-commutative71.6%
unsub-neg71.6%
Simplified71.6%
add-cbrt-cube60.5%
pow360.5%
pow1/357.9%
sqrt-pow257.9%
fma-neg57.9%
*-commutative57.9%
distribute-rgt-neg-in57.9%
metadata-eval57.9%
Applied egg-rr57.9%
unpow1/360.5%
distribute-rgt-neg-out60.5%
*-commutative60.5%
fma-neg60.4%
*-commutative60.4%
Simplified60.4%
Taylor expanded in b_2 around 0 36.2%
mul-1-neg36.2%
distribute-rgt-neg-in36.2%
Simplified36.2%
Taylor expanded in c around 0 27.0%
associate-*r/27.0%
neg-mul-127.0%
Simplified27.0%
if -1.000000000000002e-309 < b_2 Initial program 29.8%
+-commutative29.8%
unsub-neg29.8%
Simplified29.8%
Taylor expanded in b_2 around inf 64.7%
Final simplification45.0%
(FPCore (a b_2 c) :precision binary64 (if (<= b_2 -1e-309) (/ (* b_2 -2.0) a) (* (/ c b_2) -0.5)))
double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = (b_2 * -2.0) / a;
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
real(8) :: tmp
if (b_2 <= (-1d-309)) then
tmp = (b_2 * (-2.0d0)) / a
else
tmp = (c / b_2) * (-0.5d0)
end if
code = tmp
end function
public static double code(double a, double b_2, double c) {
double tmp;
if (b_2 <= -1e-309) {
tmp = (b_2 * -2.0) / a;
} else {
tmp = (c / b_2) * -0.5;
}
return tmp;
}
def code(a, b_2, c): tmp = 0 if b_2 <= -1e-309: tmp = (b_2 * -2.0) / a else: tmp = (c / b_2) * -0.5 return tmp
function code(a, b_2, c) tmp = 0.0 if (b_2 <= -1e-309) tmp = Float64(Float64(b_2 * -2.0) / a); else tmp = Float64(Float64(c / b_2) * -0.5); end return tmp end
function tmp_2 = code(a, b_2, c) tmp = 0.0; if (b_2 <= -1e-309) tmp = (b_2 * -2.0) / a; else tmp = (c / b_2) * -0.5; end tmp_2 = tmp; end
code[a_, b$95$2_, c_] := If[LessEqual[b$95$2, -1e-309], N[(N[(b$95$2 * -2.0), $MachinePrecision] / a), $MachinePrecision], N[(N[(c / b$95$2), $MachinePrecision] * -0.5), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b_2 \leq -1 \cdot 10^{-309}:\\
\;\;\;\;\frac{b_2 \cdot -2}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c}{b_2} \cdot -0.5\\
\end{array}
\end{array}
if b_2 < -1.000000000000002e-309Initial program 71.6%
+-commutative71.6%
unsub-neg71.6%
Simplified71.6%
Taylor expanded in b_2 around -inf 64.0%
*-commutative64.0%
Simplified64.0%
if -1.000000000000002e-309 < b_2 Initial program 29.8%
+-commutative29.8%
unsub-neg29.8%
Simplified29.8%
Taylor expanded in b_2 around inf 64.7%
Final simplification64.3%
(FPCore (a b_2 c) :precision binary64 (/ (- b_2) a))
double code(double a, double b_2, double c) {
return -b_2 / a;
}
real(8) function code(a, b_2, c)
real(8), intent (in) :: a
real(8), intent (in) :: b_2
real(8), intent (in) :: c
code = -b_2 / a
end function
public static double code(double a, double b_2, double c) {
return -b_2 / a;
}
def code(a, b_2, c): return -b_2 / a
function code(a, b_2, c) return Float64(Float64(-b_2) / a) end
function tmp = code(a, b_2, c) tmp = -b_2 / a; end
code[a_, b$95$2_, c_] := N[((-b$95$2) / a), $MachinePrecision]
\begin{array}{l}
\\
\frac{-b_2}{a}
\end{array}
Initial program 51.7%
+-commutative51.7%
unsub-neg51.7%
Simplified51.7%
add-cbrt-cube42.0%
pow342.0%
pow1/339.8%
sqrt-pow239.8%
fma-neg39.8%
*-commutative39.8%
distribute-rgt-neg-in39.8%
metadata-eval39.8%
Applied egg-rr39.8%
unpow1/342.0%
distribute-rgt-neg-out42.0%
*-commutative42.0%
fma-neg41.9%
*-commutative41.9%
Simplified41.9%
Taylor expanded in b_2 around 0 27.9%
mul-1-neg27.9%
distribute-rgt-neg-in27.9%
Simplified27.9%
Taylor expanded in c around 0 15.4%
associate-*r/15.4%
neg-mul-115.4%
Simplified15.4%
Final simplification15.4%
herbie shell --seed 2023256
(FPCore (a b_2 c)
:name "quad2p (problem 3.2.1, positive)"
:precision binary64
(/ (+ (- b_2) (sqrt (- (* b_2 b_2) (* a c)))) a))