
(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 4 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 (/ c (* (* (/ a a) 0.5) (- (- b) (sqrt (- (* b b) (* (* c a) 4.0)))))))
double code(double a, double b, double c) {
return c / (((a / a) * 0.5) * (-b - sqrt(((b * b) - ((c * a) * 4.0)))));
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = c / (((a / a) * 0.5d0) * (-b - sqrt(((b * b) - ((c * a) * 4.0d0)))))
end function
public static double code(double a, double b, double c) {
return c / (((a / a) * 0.5) * (-b - Math.sqrt(((b * b) - ((c * a) * 4.0)))));
}
def code(a, b, c): return c / (((a / a) * 0.5) * (-b - math.sqrt(((b * b) - ((c * a) * 4.0)))))
function code(a, b, c) return Float64(c / Float64(Float64(Float64(a / a) * 0.5) * Float64(Float64(-b) - sqrt(Float64(Float64(b * b) - Float64(Float64(c * a) * 4.0)))))) end
function tmp = code(a, b, c) tmp = c / (((a / a) * 0.5) * (-b - sqrt(((b * b) - ((c * a) * 4.0))))); end
code[a_, b_, c_] := N[(c / N[(N[(N[(a / a), $MachinePrecision] * 0.5), $MachinePrecision] * N[((-b) - N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(c * a), $MachinePrecision] * 4.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{c}{\left(\frac{a}{a} \cdot 0.5\right) \cdot \left(\left(-b\right) - \sqrt{b \cdot b - \left(c \cdot a\right) \cdot 4}\right)}
\end{array}
Initial program 31.2%
flip-+31.1%
pow231.1%
add-sqr-sqrt32.0%
*-commutative32.0%
*-commutative32.0%
*-commutative32.0%
*-commutative32.0%
Applied egg-rr32.0%
Taylor expanded in b around 0 99.5%
*-commutative99.5%
associate-*r*99.5%
Simplified99.5%
div-inv99.3%
associate-/l*99.2%
*-commutative99.2%
Applied egg-rr99.2%
associate-*r/99.4%
*-rgt-identity99.4%
associate-/r/99.6%
Simplified99.6%
expm1-log1p-u84.5%
expm1-udef38.5%
associate-/l*38.5%
Applied egg-rr38.5%
expm1-def84.5%
expm1-log1p99.7%
associate-/l/99.7%
times-frac99.7%
metadata-eval99.7%
associate-*r*99.7%
Simplified99.7%
Final simplification99.7%
(FPCore (a b c) :precision binary64 (- (/ (- c) b) (* a (/ c (/ (pow b 3.0) c)))))
double code(double a, double b, double c) {
return (-c / b) - (a * (c / (pow(b, 3.0) / c)));
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (-c / b) - (a * (c / ((b ** 3.0d0) / c)))
end function
public static double code(double a, double b, double c) {
return (-c / b) - (a * (c / (Math.pow(b, 3.0) / c)));
}
def code(a, b, c): return (-c / b) - (a * (c / (math.pow(b, 3.0) / c)))
function code(a, b, c) return Float64(Float64(Float64(-c) / b) - Float64(a * Float64(c / Float64((b ^ 3.0) / c)))) end
function tmp = code(a, b, c) tmp = (-c / b) - (a * (c / ((b ^ 3.0) / c))); end
code[a_, b_, c_] := N[(N[((-c) / b), $MachinePrecision] - N[(a * N[(c / N[(N[Power[b, 3.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{-c}{b} - a \cdot \frac{c}{\frac{{b}^{3}}{c}}
\end{array}
Initial program 31.2%
*-commutative31.2%
+-commutative31.2%
unsub-neg31.2%
fma-neg31.3%
associate-*l*31.3%
*-commutative31.3%
distribute-rgt-neg-in31.3%
metadata-eval31.3%
Simplified31.3%
Taylor expanded in b around inf 91.9%
+-commutative91.9%
mul-1-neg91.9%
unsub-neg91.9%
associate-*r/91.9%
neg-mul-191.9%
associate-/l*91.9%
associate-/r/91.9%
unpow291.9%
associate-/l*91.9%
Simplified91.9%
Final simplification91.9%
(FPCore (a b c) :precision binary64 (- (- (/ (* c (* c a)) (pow b 3.0))) (/ c b)))
double code(double a, double b, double c) {
return -((c * (c * a)) / pow(b, 3.0)) - (c / b);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = -((c * (c * a)) / (b ** 3.0d0)) - (c / b)
end function
public static double code(double a, double b, double c) {
return -((c * (c * a)) / Math.pow(b, 3.0)) - (c / b);
}
def code(a, b, c): return -((c * (c * a)) / math.pow(b, 3.0)) - (c / b)
function code(a, b, c) return Float64(Float64(-Float64(Float64(c * Float64(c * a)) / (b ^ 3.0))) - Float64(c / b)) end
function tmp = code(a, b, c) tmp = -((c * (c * a)) / (b ^ 3.0)) - (c / b); end
code[a_, b_, c_] := N[((-N[(N[(c * N[(c * a), $MachinePrecision]), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]) - N[(c / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-\frac{c \cdot \left(c \cdot a\right)}{{b}^{3}}\right) - \frac{c}{b}
\end{array}
Initial program 31.2%
flip-+31.1%
pow231.1%
add-sqr-sqrt32.0%
*-commutative32.0%
*-commutative32.0%
*-commutative32.0%
*-commutative32.0%
Applied egg-rr32.0%
Taylor expanded in b around 0 99.5%
*-commutative99.5%
associate-*r*99.5%
Simplified99.5%
div-inv99.3%
associate-/l*99.2%
*-commutative99.2%
Applied egg-rr99.2%
associate-*r/99.4%
*-rgt-identity99.4%
associate-/r/99.6%
Simplified99.6%
Taylor expanded in c around 0 91.9%
mul-1-neg91.9%
unsub-neg91.9%
associate-*r/91.9%
mul-1-neg91.9%
unpow291.9%
associate-*l*91.9%
Simplified91.9%
Final simplification91.9%
(FPCore (a b c) :precision binary64 (/ (- c) b))
double code(double a, double b, double c) {
return -c / b;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = -c / b
end function
public static double code(double a, double b, double c) {
return -c / b;
}
def code(a, b, c): return -c / b
function code(a, b, c) return Float64(Float64(-c) / b) end
function tmp = code(a, b, c) tmp = -c / b; end
code[a_, b_, c_] := N[((-c) / b), $MachinePrecision]
\begin{array}{l}
\\
\frac{-c}{b}
\end{array}
Initial program 31.2%
*-commutative31.2%
+-commutative31.2%
unsub-neg31.2%
fma-neg31.3%
associate-*l*31.3%
*-commutative31.3%
distribute-rgt-neg-in31.3%
metadata-eval31.3%
Simplified31.3%
Taylor expanded in b around inf 81.7%
associate-*r/81.7%
neg-mul-181.7%
Simplified81.7%
Final simplification81.7%
herbie shell --seed 2023240
(FPCore (a b c)
:name "Quadratic roots, medium range"
:precision binary64
:pre (and (and (and (< 1.1102230246251565e-16 a) (< a 9007199254740992.0)) (and (< 1.1102230246251565e-16 b) (< b 9007199254740992.0))) (and (< 1.1102230246251565e-16 c) (< c 9007199254740992.0)))
(/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))