
(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 9 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
(-
(*
(pow c 4.0)
(-
(* -5.0 (/ (pow a 3.0) (pow b 7.0)))
(/ (+ (* 2.0 (/ (pow a 2.0) (pow b 5.0))) (/ a (* c (pow b 3.0)))) c)))
(/ c b)))
double code(double a, double b, double c) {
return (pow(c, 4.0) * ((-5.0 * (pow(a, 3.0) / pow(b, 7.0))) - (((2.0 * (pow(a, 2.0) / pow(b, 5.0))) + (a / (c * pow(b, 3.0)))) / c))) - (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 ** 4.0d0) * (((-5.0d0) * ((a ** 3.0d0) / (b ** 7.0d0))) - (((2.0d0 * ((a ** 2.0d0) / (b ** 5.0d0))) + (a / (c * (b ** 3.0d0)))) / c))) - (c / b)
end function
public static double code(double a, double b, double c) {
return (Math.pow(c, 4.0) * ((-5.0 * (Math.pow(a, 3.0) / Math.pow(b, 7.0))) - (((2.0 * (Math.pow(a, 2.0) / Math.pow(b, 5.0))) + (a / (c * Math.pow(b, 3.0)))) / c))) - (c / b);
}
def code(a, b, c): return (math.pow(c, 4.0) * ((-5.0 * (math.pow(a, 3.0) / math.pow(b, 7.0))) - (((2.0 * (math.pow(a, 2.0) / math.pow(b, 5.0))) + (a / (c * math.pow(b, 3.0)))) / c))) - (c / b)
function code(a, b, c) return Float64(Float64((c ^ 4.0) * Float64(Float64(-5.0 * Float64((a ^ 3.0) / (b ^ 7.0))) - Float64(Float64(Float64(2.0 * Float64((a ^ 2.0) / (b ^ 5.0))) + Float64(a / Float64(c * (b ^ 3.0)))) / c))) - Float64(c / b)) end
function tmp = code(a, b, c) tmp = ((c ^ 4.0) * ((-5.0 * ((a ^ 3.0) / (b ^ 7.0))) - (((2.0 * ((a ^ 2.0) / (b ^ 5.0))) + (a / (c * (b ^ 3.0)))) / c))) - (c / b); end
code[a_, b_, c_] := N[(N[(N[Power[c, 4.0], $MachinePrecision] * N[(N[(-5.0 * N[(N[Power[a, 3.0], $MachinePrecision] / N[Power[b, 7.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(2.0 * N[(N[Power[a, 2.0], $MachinePrecision] / N[Power[b, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a / N[(c * N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{c}^{4} \cdot \left(-5 \cdot \frac{{a}^{3}}{{b}^{7}} - \frac{2 \cdot \frac{{a}^{2}}{{b}^{5}} + \frac{a}{c \cdot {b}^{3}}}{c}\right) - \frac{c}{b}
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in a around 0 96.6%
Taylor expanded in c around 0 96.6%
associate-*r/96.6%
Simplified96.6%
Taylor expanded in c around -inf 96.6%
Final simplification96.6%
(FPCore (a b c) :precision binary64 (/ (- (* (* (pow a 2.0) -2.0) (/ (pow c 3.0) (pow b 4.0))) (fma a (pow (/ (- c) b) 2.0) c)) b))
double code(double a, double b, double c) {
return (((pow(a, 2.0) * -2.0) * (pow(c, 3.0) / pow(b, 4.0))) - fma(a, pow((-c / b), 2.0), c)) / b;
}
function code(a, b, c) return Float64(Float64(Float64(Float64((a ^ 2.0) * -2.0) * Float64((c ^ 3.0) / (b ^ 4.0))) - fma(a, (Float64(Float64(-c) / b) ^ 2.0), c)) / b) end
code[a_, b_, c_] := N[(N[(N[(N[(N[Power[a, 2.0], $MachinePrecision] * -2.0), $MachinePrecision] * N[(N[Power[c, 3.0], $MachinePrecision] / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[Power[N[((-c) / b), $MachinePrecision], 2.0], $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left({a}^{2} \cdot -2\right) \cdot \frac{{c}^{3}}{{b}^{4}} - \mathsf{fma}\left(a, {\left(\frac{-c}{b}\right)}^{2}, c\right)}{b}
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 95.3%
distribute-lft-in95.3%
*-commutative95.3%
associate-/l*95.3%
mul-1-neg95.3%
div-inv95.3%
pow-flip95.3%
metadata-eval95.3%
Applied egg-rr95.3%
distribute-lft-out95.3%
unsub-neg95.3%
associate-*l*95.3%
associate-*l/95.3%
Simplified95.3%
Taylor expanded in b around inf 95.6%
Simplified95.6%
Final simplification95.6%
(FPCore (a b c) :precision binary64 (* c (+ (* c (- (* (pow a 2.0) (/ (* c -2.0) (pow b 5.0))) (* a (pow b -3.0)))) (/ -1.0 b))))
double code(double a, double b, double c) {
return c * ((c * ((pow(a, 2.0) * ((c * -2.0) / pow(b, 5.0))) - (a * pow(b, -3.0)))) + (-1.0 / 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 ** 2.0d0) * ((c * (-2.0d0)) / (b ** 5.0d0))) - (a * (b ** (-3.0d0))))) + ((-1.0d0) / b))
end function
public static double code(double a, double b, double c) {
return c * ((c * ((Math.pow(a, 2.0) * ((c * -2.0) / Math.pow(b, 5.0))) - (a * Math.pow(b, -3.0)))) + (-1.0 / b));
}
def code(a, b, c): return c * ((c * ((math.pow(a, 2.0) * ((c * -2.0) / math.pow(b, 5.0))) - (a * math.pow(b, -3.0)))) + (-1.0 / b))
function code(a, b, c) return Float64(c * Float64(Float64(c * Float64(Float64((a ^ 2.0) * Float64(Float64(c * -2.0) / (b ^ 5.0))) - Float64(a * (b ^ -3.0)))) + Float64(-1.0 / b))) end
function tmp = code(a, b, c) tmp = c * ((c * (((a ^ 2.0) * ((c * -2.0) / (b ^ 5.0))) - (a * (b ^ -3.0)))) + (-1.0 / b)); end
code[a_, b_, c_] := N[(c * N[(N[(c * N[(N[(N[Power[a, 2.0], $MachinePrecision] * N[(N[(c * -2.0), $MachinePrecision] / N[Power[b, 5.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[Power[b, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c \cdot \left(c \cdot \left({a}^{2} \cdot \frac{c \cdot -2}{{b}^{5}} - a \cdot {b}^{-3}\right) + \frac{-1}{b}\right)
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 95.3%
distribute-lft-in95.3%
*-commutative95.3%
associate-/l*95.3%
mul-1-neg95.3%
div-inv95.3%
pow-flip95.3%
metadata-eval95.3%
Applied egg-rr95.3%
distribute-lft-out95.3%
unsub-neg95.3%
associate-*l*95.3%
associate-*l/95.3%
Simplified95.3%
Final simplification95.3%
(FPCore (a b c) :precision binary64 (/ (+ c (* a (/ (pow c 2.0) (pow b 2.0)))) (- b)))
double code(double a, double b, double c) {
return (c + (a * (pow(c, 2.0) / pow(b, 2.0)))) / -b;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (c + (a * ((c ** 2.0d0) / (b ** 2.0d0)))) / -b
end function
public static double code(double a, double b, double c) {
return (c + (a * (Math.pow(c, 2.0) / Math.pow(b, 2.0)))) / -b;
}
def code(a, b, c): return (c + (a * (math.pow(c, 2.0) / math.pow(b, 2.0)))) / -b
function code(a, b, c) return Float64(Float64(c + Float64(a * Float64((c ^ 2.0) / (b ^ 2.0)))) / Float64(-b)) end
function tmp = code(a, b, c) tmp = (c + (a * ((c ^ 2.0) / (b ^ 2.0)))) / -b; end
code[a_, b_, c_] := N[(N[(c + N[(a * N[(N[Power[c, 2.0], $MachinePrecision] / N[Power[b, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / (-b)), $MachinePrecision]
\begin{array}{l}
\\
\frac{c + a \cdot \frac{{c}^{2}}{{b}^{2}}}{-b}
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in b around inf 94.0%
mul-1-neg94.0%
unsub-neg94.0%
mul-1-neg94.0%
associate-/l*94.0%
Simplified94.0%
Final simplification94.0%
(FPCore (a b c) :precision binary64 (/ (* a (+ (pow (/ c b) 2.0) (/ c a))) (- b)))
double code(double a, double b, double c) {
return (a * (pow((c / b), 2.0) + (c / a))) / -b;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (a * (((c / b) ** 2.0d0) + (c / a))) / -b
end function
public static double code(double a, double b, double c) {
return (a * (Math.pow((c / b), 2.0) + (c / a))) / -b;
}
def code(a, b, c): return (a * (math.pow((c / b), 2.0) + (c / a))) / -b
function code(a, b, c) return Float64(Float64(a * Float64((Float64(c / b) ^ 2.0) + Float64(c / a))) / Float64(-b)) end
function tmp = code(a, b, c) tmp = (a * (((c / b) ^ 2.0) + (c / a))) / -b; end
code[a_, b_, c_] := N[(N[(a * N[(N[Power[N[(c / b), $MachinePrecision], 2.0], $MachinePrecision] + N[(c / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / (-b)), $MachinePrecision]
\begin{array}{l}
\\
\frac{a \cdot \left({\left(\frac{c}{b}\right)}^{2} + \frac{c}{a}\right)}{-b}
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 93.7%
associate-*r/93.7%
neg-mul-193.7%
distribute-rgt-neg-in93.7%
Simplified93.7%
Taylor expanded in a around inf 93.6%
mul-1-neg93.6%
unsub-neg93.6%
associate-*r/93.6%
neg-mul-193.6%
associate-/r*93.6%
Simplified93.6%
Taylor expanded in c around 0 93.5%
sub-neg93.5%
+-commutative93.5%
mul-1-neg93.5%
unsub-neg93.5%
neg-sub093.5%
div093.5%
*-commutative93.5%
associate-/r*93.4%
div-sub93.4%
neg-sub093.4%
distribute-neg-frac93.4%
metadata-eval93.4%
Simplified93.4%
Taylor expanded in a around inf 93.6%
mul-1-neg93.6%
unsub-neg93.6%
associate-/r*93.6%
associate-*r/93.6%
unpow393.6%
unpow293.6%
associate-/r*93.6%
div-sub93.6%
unsub-neg93.6%
mul-1-neg93.6%
distribute-lft-out93.6%
associate-*r/93.6%
mul-1-neg93.6%
distribute-neg-frac293.6%
Simplified93.6%
associate-*r/93.9%
+-commutative93.9%
Applied egg-rr93.9%
(FPCore (a b c) :precision binary64 (* c (- (/ -1.0 b) (* (pow b -3.0) (* c a)))))
double code(double a, double b, double c) {
return c * ((-1.0 / b) - (pow(b, -3.0) * (c * a)));
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = c * (((-1.0d0) / b) - ((b ** (-3.0d0)) * (c * a)))
end function
public static double code(double a, double b, double c) {
return c * ((-1.0 / b) - (Math.pow(b, -3.0) * (c * a)));
}
def code(a, b, c): return c * ((-1.0 / b) - (math.pow(b, -3.0) * (c * a)))
function code(a, b, c) return Float64(c * Float64(Float64(-1.0 / b) - Float64((b ^ -3.0) * Float64(c * a)))) end
function tmp = code(a, b, c) tmp = c * ((-1.0 / b) - ((b ^ -3.0) * (c * a))); end
code[a_, b_, c_] := N[(c * N[(N[(-1.0 / b), $MachinePrecision] - N[(N[Power[b, -3.0], $MachinePrecision] * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c \cdot \left(\frac{-1}{b} - {b}^{-3} \cdot \left(c \cdot a\right)\right)
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 93.7%
associate-*r/93.7%
neg-mul-193.7%
distribute-rgt-neg-in93.7%
Simplified93.7%
pow193.7%
div-inv93.7%
fma-neg93.7%
distribute-rgt-neg-out93.7%
pow-flip93.7%
metadata-eval93.7%
Applied egg-rr93.7%
unpow193.7%
fma-define93.7%
+-commutative93.7%
cancel-sign-sub-inv93.7%
distribute-neg-frac93.7%
metadata-eval93.7%
*-commutative93.7%
Simplified93.7%
Final simplification93.7%
(FPCore (a b c) :precision binary64 (* a (/ (- (/ (- c) a) (* (/ c b) (/ c b))) b)))
double code(double a, double b, double c) {
return a * (((-c / a) - ((c / b) * (c / b))) / b);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = a * (((-c / a) - ((c / b) * (c / b))) / b)
end function
public static double code(double a, double b, double c) {
return a * (((-c / a) - ((c / b) * (c / b))) / b);
}
def code(a, b, c): return a * (((-c / a) - ((c / b) * (c / b))) / b)
function code(a, b, c) return Float64(a * Float64(Float64(Float64(Float64(-c) / a) - Float64(Float64(c / b) * Float64(c / b))) / b)) end
function tmp = code(a, b, c) tmp = a * (((-c / a) - ((c / b) * (c / b))) / b); end
code[a_, b_, c_] := N[(a * N[(N[(N[((-c) / a), $MachinePrecision] - N[(N[(c / b), $MachinePrecision] * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \frac{\frac{-c}{a} - \frac{c}{b} \cdot \frac{c}{b}}{b}
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 93.7%
associate-*r/93.7%
neg-mul-193.7%
distribute-rgt-neg-in93.7%
Simplified93.7%
Taylor expanded in a around inf 93.6%
mul-1-neg93.6%
unsub-neg93.6%
associate-*r/93.6%
neg-mul-193.6%
associate-/r*93.6%
Simplified93.6%
Taylor expanded in c around 0 93.5%
sub-neg93.5%
+-commutative93.5%
mul-1-neg93.5%
unsub-neg93.5%
neg-sub093.5%
div093.5%
*-commutative93.5%
associate-/r*93.4%
div-sub93.4%
neg-sub093.4%
distribute-neg-frac93.4%
metadata-eval93.4%
Simplified93.4%
Taylor expanded in a around inf 93.6%
mul-1-neg93.6%
unsub-neg93.6%
associate-/r*93.6%
associate-*r/93.6%
unpow393.6%
unpow293.6%
associate-/r*93.6%
div-sub93.6%
unsub-neg93.6%
mul-1-neg93.6%
distribute-lft-out93.6%
associate-*r/93.6%
mul-1-neg93.6%
distribute-neg-frac293.6%
Simplified93.6%
unpow293.6%
Applied egg-rr93.6%
Final simplification93.6%
(FPCore (a b c) :precision binary64 (/ c (- b)))
double code(double a, double b, double c) {
return c / -b;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = c / -b
end function
public static double code(double a, double b, double c) {
return c / -b;
}
def code(a, b, c): return c / -b
function code(a, b, c) return Float64(c / Float64(-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 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in b around inf 89.6%
associate-*r/89.6%
mul-1-neg89.6%
Simplified89.6%
Final simplification89.6%
(FPCore (a b c) :precision binary64 0.0)
double code(double a, double b, double c) {
return 0.0;
}
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
end function
public static double code(double a, double b, double c) {
return 0.0;
}
def code(a, b, c): return 0.0
function code(a, b, c) return 0.0 end
function tmp = code(a, b, c) tmp = 0.0; end
code[a_, b_, c_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 18.3%
*-commutative18.3%
Simplified18.3%
Taylor expanded in c around 0 93.7%
associate-*r/93.7%
neg-mul-193.7%
distribute-rgt-neg-in93.7%
Simplified93.7%
Taylor expanded in a around 0 89.4%
expm1-log1p-u78.9%
expm1-undefine17.6%
associate-*r/17.6%
Applied egg-rr17.6%
sub-neg17.6%
metadata-eval17.6%
+-commutative17.6%
log1p-undefine17.6%
rem-exp-log28.1%
*-commutative28.1%
associate-*r/28.1%
mul-1-neg28.1%
unsub-neg28.1%
Simplified28.1%
Taylor expanded in c around 0 3.3%
Final simplification3.3%
herbie shell --seed 2024107
(FPCore (a b c)
:name "Quadratic roots, wide range"
:precision binary64
:pre (and (and (and (< 4.930380657631324e-32 a) (< a 2.028240960365167e+31)) (and (< 4.930380657631324e-32 b) (< b 2.028240960365167e+31))) (and (< 4.930380657631324e-32 c) (< c 2.028240960365167e+31)))
(/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))