
(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 13 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 (pow (fma a (* c -4.0) (pow b 2.0)) 0.25))) (* 0.5 (/ (/ (+ (* (pow b 2.0) 0.0) (* a (* c -4.0))) (fma t_0 t_0 b)) a))))
double code(double a, double b, double c) {
double t_0 = pow(fma(a, (c * -4.0), pow(b, 2.0)), 0.25);
return 0.5 * ((((pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / fma(t_0, t_0, b)) / a);
}
function code(a, b, c) t_0 = fma(a, Float64(c * -4.0), (b ^ 2.0)) ^ 0.25 return Float64(0.5 * Float64(Float64(Float64(Float64((b ^ 2.0) * 0.0) + Float64(a * Float64(c * -4.0))) / fma(t_0, t_0, b)) / a)) end
code[a_, b_, c_] := Block[{t$95$0 = N[Power[N[(a * N[(c * -4.0), $MachinePrecision] + N[Power[b, 2.0], $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]}, N[(0.5 * N[(N[(N[(N[(N[Power[b, 2.0], $MachinePrecision] * 0.0), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$0 * t$95$0 + b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {\left(\mathsf{fma}\left(a, c \cdot -4, {b}^{2}\right)\right)}^{0.25}\\
0.5 \cdot \frac{\frac{{b}^{2} \cdot 0 + a \cdot \left(c \cdot -4\right)}{\mathsf{fma}\left(t\_0, t\_0, b\right)}}{a}
\end{array}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
un-div-inv56.4%
distribute-frac-neg256.4%
+-commutative56.4%
Applied egg-rr56.4%
neg-mul-156.4%
*-commutative56.4%
times-frac56.4%
metadata-eval56.4%
Simplified99.3%
+-commutative99.3%
fma-define99.3%
add-sqr-sqrt99.2%
fma-define99.3%
pow1/299.3%
sqrt-pow199.3%
fma-define99.3%
metadata-eval99.3%
pow1/299.3%
sqrt-pow199.3%
fma-define99.3%
metadata-eval99.3%
Applied egg-rr99.3%
Final simplification99.3%
(FPCore (a b c)
:precision binary64
(*
0.5
(/
(/
(+ (* (pow b 2.0) 0.0) (* a (* c -4.0)))
(+ b (sqrt (fma a (* c -4.0) (pow b 2.0)))))
a)))
double code(double a, double b, double c) {
return 0.5 * ((((pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / (b + sqrt(fma(a, (c * -4.0), pow(b, 2.0))))) / a);
}
function code(a, b, c) return Float64(0.5 * Float64(Float64(Float64(Float64((b ^ 2.0) * 0.0) + Float64(a * Float64(c * -4.0))) / Float64(b + sqrt(fma(a, Float64(c * -4.0), (b ^ 2.0))))) / a)) end
code[a_, b_, c_] := N[(0.5 * N[(N[(N[(N[(N[Power[b, 2.0], $MachinePrecision] * 0.0), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b + N[Sqrt[N[(a * N[(c * -4.0), $MachinePrecision] + N[Power[b, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \frac{\frac{{b}^{2} \cdot 0 + a \cdot \left(c \cdot -4\right)}{b + \sqrt{\mathsf{fma}\left(a, c \cdot -4, {b}^{2}\right)}}}{a}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
un-div-inv56.4%
distribute-frac-neg256.4%
+-commutative56.4%
Applied egg-rr56.4%
neg-mul-156.4%
*-commutative56.4%
times-frac56.4%
metadata-eval56.4%
Simplified99.3%
Final simplification99.3%
(FPCore (a b c)
:precision binary64
(*
0.5
(/
(/
(+ (* (pow b 2.0) 0.0) (* a (* c -4.0)))
(+ b (sqrt (* c (+ (* a -4.0) (/ (pow b 2.0) c))))))
a)))
double code(double a, double b, double c) {
return 0.5 * ((((pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / (b + sqrt((c * ((a * -4.0) + (pow(b, 2.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 = 0.5d0 * (((((b ** 2.0d0) * 0.0d0) + (a * (c * (-4.0d0)))) / (b + sqrt((c * ((a * (-4.0d0)) + ((b ** 2.0d0) / c)))))) / a)
end function
public static double code(double a, double b, double c) {
return 0.5 * ((((Math.pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / (b + Math.sqrt((c * ((a * -4.0) + (Math.pow(b, 2.0) / c)))))) / a);
}
def code(a, b, c): return 0.5 * ((((math.pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / (b + math.sqrt((c * ((a * -4.0) + (math.pow(b, 2.0) / c)))))) / a)
function code(a, b, c) return Float64(0.5 * Float64(Float64(Float64(Float64((b ^ 2.0) * 0.0) + Float64(a * Float64(c * -4.0))) / Float64(b + sqrt(Float64(c * Float64(Float64(a * -4.0) + Float64((b ^ 2.0) / c)))))) / a)) end
function tmp = code(a, b, c) tmp = 0.5 * (((((b ^ 2.0) * 0.0) + (a * (c * -4.0))) / (b + sqrt((c * ((a * -4.0) + ((b ^ 2.0) / c)))))) / a); end
code[a_, b_, c_] := N[(0.5 * N[(N[(N[(N[(N[Power[b, 2.0], $MachinePrecision] * 0.0), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b + N[Sqrt[N[(c * N[(N[(a * -4.0), $MachinePrecision] + N[(N[Power[b, 2.0], $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \frac{\frac{{b}^{2} \cdot 0 + a \cdot \left(c \cdot -4\right)}{b + \sqrt{c \cdot \left(a \cdot -4 + \frac{{b}^{2}}{c}\right)}}}{a}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
un-div-inv56.4%
distribute-frac-neg256.4%
+-commutative56.4%
Applied egg-rr56.4%
neg-mul-156.4%
*-commutative56.4%
times-frac56.4%
metadata-eval56.4%
Simplified99.3%
Taylor expanded in c around inf 99.3%
Final simplification99.3%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* a (* c -4.0))))
(*
0.5
(/ (/ (+ (* (pow b 2.0) 0.0) t_0) (+ b (sqrt (+ (pow b 2.0) t_0)))) a))))
double code(double a, double b, double c) {
double t_0 = a * (c * -4.0);
return 0.5 * ((((pow(b, 2.0) * 0.0) + t_0) / (b + sqrt((pow(b, 2.0) + t_0)))) / a);
}
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
t_0 = a * (c * (-4.0d0))
code = 0.5d0 * (((((b ** 2.0d0) * 0.0d0) + t_0) / (b + sqrt(((b ** 2.0d0) + t_0)))) / a)
end function
public static double code(double a, double b, double c) {
double t_0 = a * (c * -4.0);
return 0.5 * ((((Math.pow(b, 2.0) * 0.0) + t_0) / (b + Math.sqrt((Math.pow(b, 2.0) + t_0)))) / a);
}
def code(a, b, c): t_0 = a * (c * -4.0) return 0.5 * ((((math.pow(b, 2.0) * 0.0) + t_0) / (b + math.sqrt((math.pow(b, 2.0) + t_0)))) / a)
function code(a, b, c) t_0 = Float64(a * Float64(c * -4.0)) return Float64(0.5 * Float64(Float64(Float64(Float64((b ^ 2.0) * 0.0) + t_0) / Float64(b + sqrt(Float64((b ^ 2.0) + t_0)))) / a)) end
function tmp = code(a, b, c) t_0 = a * (c * -4.0); tmp = 0.5 * (((((b ^ 2.0) * 0.0) + t_0) / (b + sqrt(((b ^ 2.0) + t_0)))) / a); end
code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]}, N[(0.5 * N[(N[(N[(N[(N[Power[b, 2.0], $MachinePrecision] * 0.0), $MachinePrecision] + t$95$0), $MachinePrecision] / N[(b + N[Sqrt[N[(N[Power[b, 2.0], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := a \cdot \left(c \cdot -4\right)\\
0.5 \cdot \frac{\frac{{b}^{2} \cdot 0 + t\_0}{b + \sqrt{{b}^{2} + t\_0}}}{a}
\end{array}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
un-div-inv56.4%
distribute-frac-neg256.4%
+-commutative56.4%
Applied egg-rr56.4%
neg-mul-156.4%
*-commutative56.4%
times-frac56.4%
metadata-eval56.4%
Simplified99.3%
fma-undefine99.3%
Applied egg-rr99.3%
Final simplification99.3%
(FPCore (a b c) :precision binary64 (* (/ (* a (* c -4.0)) (+ b (sqrt (fma (* a c) -4.0 (pow b 2.0))))) (/ -1.0 (* a -2.0))))
double code(double a, double b, double c) {
return ((a * (c * -4.0)) / (b + sqrt(fma((a * c), -4.0, pow(b, 2.0))))) * (-1.0 / (a * -2.0));
}
function code(a, b, c) return Float64(Float64(Float64(a * Float64(c * -4.0)) / Float64(b + sqrt(fma(Float64(a * c), -4.0, (b ^ 2.0))))) * Float64(-1.0 / Float64(a * -2.0))) end
code[a_, b_, c_] := N[(N[(N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision] / N[(b + N[Sqrt[N[(N[(a * c), $MachinePrecision] * -4.0 + N[Power[b, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(-1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{a \cdot \left(c \cdot -4\right)}{b + \sqrt{\mathsf{fma}\left(a \cdot c, -4, {b}^{2}\right)}} \cdot \frac{-1}{a \cdot -2}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
Taylor expanded in a around 0 99.2%
*-commutative99.2%
associate-*l*99.2%
Simplified99.2%
Final simplification99.2%
(FPCore (a b c)
:precision binary64
(if (<= b 0.27)
(/ (- (sqrt (fma a (* c -4.0) (* b b))) b) (* 2.0 a))
(*
(/ 1.0 (* a -2.0))
(/
1.0
(/
(+
(* 0.5 (/ b c))
(* a (+ (* -0.5 (/ (* a c) (pow b 3.0))) (* 0.5 (/ -1.0 b)))))
a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 0.27) {
tmp = (sqrt(fma(a, (c * -4.0), (b * b))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / a));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 0.27) tmp = Float64(Float64(sqrt(fma(a, Float64(c * -4.0), Float64(b * b))) - b) / Float64(2.0 * a)); else tmp = Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / c)) + Float64(a * Float64(Float64(-0.5 * Float64(Float64(a * c) / (b ^ 3.0))) + Float64(0.5 * Float64(-1.0 / b))))) / a))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 0.27], N[(N[(N[Sqrt[N[(a * N[(c * -4.0), $MachinePrecision] + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / c), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(-0.5 * N[(N[(a * c), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 0.27:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(a, c \cdot -4, b \cdot b\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{c} + a \cdot \left(-0.5 \cdot \frac{a \cdot c}{{b}^{3}} + 0.5 \cdot \frac{-1}{b}\right)}{a}}\\
\end{array}
\end{array}
if b < 0.27000000000000002Initial program 87.0%
Simplified87.1%
if 0.27000000000000002 < b Initial program 50.2%
Simplified50.2%
frac-2neg50.2%
div-inv50.2%
sub-neg50.2%
distribute-neg-in50.2%
pow250.2%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod50.2%
sqr-neg50.2%
sqrt-prod49.0%
add-sqr-sqrt50.2%
distribute-rgt-neg-in50.2%
metadata-eval50.2%
Applied egg-rr50.2%
flip-+50.0%
pow250.0%
unpow250.0%
Applied egg-rr50.0%
unpow250.0%
sqr-neg50.0%
rem-square-sqrt51.8%
fma-define51.8%
associate-*r*51.8%
fma-define51.8%
sub-neg51.8%
distribute-neg-out51.8%
fma-define51.7%
associate-*r*51.7%
fma-define51.7%
Simplified51.7%
clear-num51.7%
inv-pow51.7%
+-commutative51.7%
Applied egg-rr51.7%
unpow-151.7%
distribute-frac-neg51.7%
distribute-neg-frac251.7%
fma-define51.7%
associate-*l*51.7%
*-commutative51.7%
fma-define51.7%
*-commutative51.7%
sub-neg51.7%
+-commutative51.7%
fma-define51.7%
+-commutative51.7%
*-commutative51.7%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in a around 0 90.5%
Final simplification90.1%
(FPCore (a b c)
:precision binary64
(if (<= b 0.6)
(/ (- (sqrt (fma b b (* c (* a -4.0)))) b) (* 2.0 a))
(*
(/ 1.0 (* a -2.0))
(/
1.0
(/
(+
(* 0.5 (/ b c))
(* a (+ (* -0.5 (/ (* a c) (pow b 3.0))) (* 0.5 (/ -1.0 b)))))
a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 0.6) {
tmp = (sqrt(fma(b, b, (c * (a * -4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / a));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (b <= 0.6) tmp = Float64(Float64(sqrt(fma(b, b, Float64(c * Float64(a * -4.0)))) - b) / Float64(2.0 * a)); else tmp = Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / c)) + Float64(a * Float64(Float64(-0.5 * Float64(Float64(a * c) / (b ^ 3.0))) + Float64(0.5 * Float64(-1.0 / b))))) / a))); end return tmp end
code[a_, b_, c_] := If[LessEqual[b, 0.6], N[(N[(N[Sqrt[N[(b * b + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / c), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(-0.5 * N[(N[(a * c), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 0.6:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(b, b, c \cdot \left(a \cdot -4\right)\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{c} + a \cdot \left(-0.5 \cdot \frac{a \cdot c}{{b}^{3}} + 0.5 \cdot \frac{-1}{b}\right)}{a}}\\
\end{array}
\end{array}
if b < 0.599999999999999978Initial program 87.0%
*-commutative87.0%
Simplified87.2%
if 0.599999999999999978 < b Initial program 50.2%
Simplified50.2%
frac-2neg50.2%
div-inv50.2%
sub-neg50.2%
distribute-neg-in50.2%
pow250.2%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod50.2%
sqr-neg50.2%
sqrt-prod49.0%
add-sqr-sqrt50.2%
distribute-rgt-neg-in50.2%
metadata-eval50.2%
Applied egg-rr50.2%
flip-+50.0%
pow250.0%
unpow250.0%
Applied egg-rr50.0%
unpow250.0%
sqr-neg50.0%
rem-square-sqrt51.8%
fma-define51.8%
associate-*r*51.8%
fma-define51.8%
sub-neg51.8%
distribute-neg-out51.8%
fma-define51.7%
associate-*r*51.7%
fma-define51.7%
Simplified51.7%
clear-num51.7%
inv-pow51.7%
+-commutative51.7%
Applied egg-rr51.7%
unpow-151.7%
distribute-frac-neg51.7%
distribute-neg-frac251.7%
fma-define51.7%
associate-*l*51.7%
*-commutative51.7%
fma-define51.7%
*-commutative51.7%
sub-neg51.7%
+-commutative51.7%
fma-define51.7%
+-commutative51.7%
*-commutative51.7%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in a around 0 90.5%
Final simplification90.1%
(FPCore (a b c)
:precision binary64
(if (<= b 0.31)
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))
(*
(/ 1.0 (* a -2.0))
(/
1.0
(/
(+
(* 0.5 (/ b a))
(* c (+ (* -0.5 (/ (* a c) (pow b 3.0))) (* 0.5 (/ -1.0 b)))))
c)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 0.31) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (c * ((-0.5 * ((a * c) / pow(b, 3.0))) + (0.5 * (-1.0 / 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 <= 0.31d0) then
tmp = (sqrt(((b * b) - (c * (a * 4.0d0)))) - b) / (2.0d0 * a)
else
tmp = (1.0d0 / (a * (-2.0d0))) * (1.0d0 / (((0.5d0 * (b / a)) + (c * (((-0.5d0) * ((a * c) / (b ** 3.0d0))) + (0.5d0 * ((-1.0d0) / b))))) / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 0.31) {
tmp = (Math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (c * ((-0.5 * ((a * c) / Math.pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / c));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 0.31: tmp = (math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a) else: tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (c * ((-0.5 * ((a * c) / math.pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / c)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= 0.31) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); else tmp = Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / a)) + Float64(c * Float64(Float64(-0.5 * Float64(Float64(a * c) / (b ^ 3.0))) + Float64(0.5 * Float64(-1.0 / b))))) / c))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 0.31) tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a); else tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (c * ((-0.5 * ((a * c) / (b ^ 3.0))) + (0.5 * (-1.0 / b))))) / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 0.31], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(-0.5 * N[(N[(a * c), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 0.31:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{a} + c \cdot \left(-0.5 \cdot \frac{a \cdot c}{{b}^{3}} + 0.5 \cdot \frac{-1}{b}\right)}{c}}\\
\end{array}
\end{array}
if b < 0.309999999999999998Initial program 87.0%
if 0.309999999999999998 < b Initial program 50.2%
Simplified50.2%
frac-2neg50.2%
div-inv50.2%
sub-neg50.2%
distribute-neg-in50.2%
pow250.2%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod50.2%
sqr-neg50.2%
sqrt-prod49.0%
add-sqr-sqrt50.2%
distribute-rgt-neg-in50.2%
metadata-eval50.2%
Applied egg-rr50.2%
flip-+50.0%
pow250.0%
unpow250.0%
Applied egg-rr50.0%
unpow250.0%
sqr-neg50.0%
rem-square-sqrt51.8%
fma-define51.8%
associate-*r*51.8%
fma-define51.8%
sub-neg51.8%
distribute-neg-out51.8%
fma-define51.7%
associate-*r*51.7%
fma-define51.7%
Simplified51.7%
clear-num51.7%
inv-pow51.7%
+-commutative51.7%
Applied egg-rr51.7%
unpow-151.7%
distribute-frac-neg51.7%
distribute-neg-frac251.7%
fma-define51.7%
associate-*l*51.7%
*-commutative51.7%
fma-define51.7%
*-commutative51.7%
sub-neg51.7%
+-commutative51.7%
fma-define51.7%
+-commutative51.7%
*-commutative51.7%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in c around 0 90.5%
Final simplification90.1%
(FPCore (a b c)
:precision binary64
(if (<= b 0.27)
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))
(*
(/ 1.0 (* a -2.0))
(/
1.0
(/
(+
(* 0.5 (/ b c))
(* a (+ (* -0.5 (/ (* a c) (pow b 3.0))) (* 0.5 (/ -1.0 b)))))
a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 0.27) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / a));
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= 0.27d0) then
tmp = (sqrt(((b * b) - (c * (a * 4.0d0)))) - b) / (2.0d0 * a)
else
tmp = (1.0d0 / (a * (-2.0d0))) * (1.0d0 / (((0.5d0 * (b / c)) + (a * (((-0.5d0) * ((a * c) / (b ** 3.0d0))) + (0.5d0 * ((-1.0d0) / b))))) / a))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 0.27) {
tmp = (Math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / Math.pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / a));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 0.27: tmp = (math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a) else: tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / math.pow(b, 3.0))) + (0.5 * (-1.0 / b))))) / a)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= 0.27) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); else tmp = Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / c)) + Float64(a * Float64(Float64(-0.5 * Float64(Float64(a * c) / (b ^ 3.0))) + Float64(0.5 * Float64(-1.0 / b))))) / a))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 0.27) tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a); else tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (a * ((-0.5 * ((a * c) / (b ^ 3.0))) + (0.5 * (-1.0 / b))))) / a)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 0.27], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / c), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(-0.5 * N[(N[(a * c), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(-1.0 / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 0.27:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{c} + a \cdot \left(-0.5 \cdot \frac{a \cdot c}{{b}^{3}} + 0.5 \cdot \frac{-1}{b}\right)}{a}}\\
\end{array}
\end{array}
if b < 0.27000000000000002Initial program 87.0%
if 0.27000000000000002 < b Initial program 50.2%
Simplified50.2%
frac-2neg50.2%
div-inv50.2%
sub-neg50.2%
distribute-neg-in50.2%
pow250.2%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod50.2%
sqr-neg50.2%
sqrt-prod49.0%
add-sqr-sqrt50.2%
distribute-rgt-neg-in50.2%
metadata-eval50.2%
Applied egg-rr50.2%
flip-+50.0%
pow250.0%
unpow250.0%
Applied egg-rr50.0%
unpow250.0%
sqr-neg50.0%
rem-square-sqrt51.8%
fma-define51.8%
associate-*r*51.8%
fma-define51.8%
sub-neg51.8%
distribute-neg-out51.8%
fma-define51.7%
associate-*r*51.7%
fma-define51.7%
Simplified51.7%
clear-num51.7%
inv-pow51.7%
+-commutative51.7%
Applied egg-rr51.7%
unpow-151.7%
distribute-frac-neg51.7%
distribute-neg-frac251.7%
fma-define51.7%
associate-*l*51.7%
*-commutative51.7%
fma-define51.7%
*-commutative51.7%
sub-neg51.7%
+-commutative51.7%
fma-define51.7%
+-commutative51.7%
*-commutative51.7%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in a around 0 90.5%
Final simplification90.1%
(FPCore (a b c)
:precision binary64
(if (<= b 2.3)
(/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a))
(*
0.5
(/
(/
(+ (* (pow b 2.0) 0.0) (* a (* c -4.0)))
(+ (* -2.0 (/ (* a c) b)) (* b 2.0)))
a))))
double code(double a, double b, double c) {
double tmp;
if (b <= 2.3) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = 0.5 * ((((pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / ((-2.0 * ((a * c) / b)) + (b * 2.0))) / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= 2.3d0) then
tmp = (sqrt(((b * b) - (c * (a * 4.0d0)))) - b) / (2.0d0 * a)
else
tmp = 0.5d0 * (((((b ** 2.0d0) * 0.0d0) + (a * (c * (-4.0d0)))) / (((-2.0d0) * ((a * c) / b)) + (b * 2.0d0))) / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 2.3) {
tmp = (Math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = 0.5 * ((((Math.pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / ((-2.0 * ((a * c) / b)) + (b * 2.0))) / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 2.3: tmp = (math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a) else: tmp = 0.5 * ((((math.pow(b, 2.0) * 0.0) + (a * (c * -4.0))) / ((-2.0 * ((a * c) / b)) + (b * 2.0))) / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= 2.3) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); else tmp = Float64(0.5 * Float64(Float64(Float64(Float64((b ^ 2.0) * 0.0) + Float64(a * Float64(c * -4.0))) / Float64(Float64(-2.0 * Float64(Float64(a * c) / b)) + Float64(b * 2.0))) / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 2.3) tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a); else tmp = 0.5 * (((((b ^ 2.0) * 0.0) + (a * (c * -4.0))) / ((-2.0 * ((a * c) / b)) + (b * 2.0))) / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 2.3], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(N[(N[(N[(N[Power[b, 2.0], $MachinePrecision] * 0.0), $MachinePrecision] + N[(a * N[(c * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(-2.0 * N[(N[(a * c), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision] + N[(b * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.3:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{\frac{{b}^{2} \cdot 0 + a \cdot \left(c \cdot -4\right)}{-2 \cdot \frac{a \cdot c}{b} + b \cdot 2}}{a}\\
\end{array}
\end{array}
if b < 2.2999999999999998Initial program 85.8%
if 2.2999999999999998 < b Initial program 49.4%
Simplified49.4%
frac-2neg49.4%
div-inv49.4%
sub-neg49.4%
distribute-neg-in49.4%
pow249.4%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod49.4%
sqr-neg49.4%
sqrt-prod48.2%
add-sqr-sqrt49.4%
distribute-rgt-neg-in49.4%
metadata-eval49.4%
Applied egg-rr49.4%
flip-+49.3%
pow249.3%
unpow249.3%
Applied egg-rr49.3%
unpow249.3%
sqr-neg49.3%
rem-square-sqrt51.0%
fma-define51.0%
associate-*r*51.0%
fma-define51.0%
sub-neg51.0%
distribute-neg-out51.0%
fma-define51.0%
associate-*r*51.0%
fma-define51.0%
Simplified51.0%
un-div-inv51.0%
distribute-frac-neg251.0%
+-commutative51.0%
Applied egg-rr51.0%
neg-mul-151.0%
*-commutative51.0%
times-frac51.0%
metadata-eval51.0%
Simplified99.3%
Taylor expanded in a around 0 85.9%
Final simplification85.9%
(FPCore (a b c) :precision binary64 (if (<= b 2.3) (/ (- (sqrt (- (* b b) (* c (* a 4.0)))) b) (* 2.0 a)) (* (/ 1.0 (* a -2.0)) (/ 1.0 (/ (+ (* 0.5 (/ b a)) (* -0.5 (/ c b))) c)))))
double code(double a, double b, double c) {
double tmp;
if (b <= 2.3) {
tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (-0.5 * (c / 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 <= 2.3d0) then
tmp = (sqrt(((b * b) - (c * (a * 4.0d0)))) - b) / (2.0d0 * a)
else
tmp = (1.0d0 / (a * (-2.0d0))) * (1.0d0 / (((0.5d0 * (b / a)) + ((-0.5d0) * (c / b))) / c))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= 2.3) {
tmp = (Math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a);
} else {
tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (-0.5 * (c / b))) / c));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= 2.3: tmp = (math.sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a) else: tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (-0.5 * (c / b))) / c)) return tmp
function code(a, b, c) tmp = 0.0 if (b <= 2.3) tmp = Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(c * Float64(a * 4.0)))) - b) / Float64(2.0 * a)); else tmp = Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / a)) + Float64(-0.5 * Float64(c / b))) / c))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= 2.3) tmp = (sqrt(((b * b) - (c * (a * 4.0)))) - b) / (2.0 * a); else tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / a)) + (-0.5 * (c / b))) / c)); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, 2.3], N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(c * N[(a * 4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / a), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(c / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2.3:\\
\;\;\;\;\frac{\sqrt{b \cdot b - c \cdot \left(a \cdot 4\right)} - b}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{a} + -0.5 \cdot \frac{c}{b}}{c}}\\
\end{array}
\end{array}
if b < 2.2999999999999998Initial program 85.8%
if 2.2999999999999998 < b Initial program 49.4%
Simplified49.4%
frac-2neg49.4%
div-inv49.4%
sub-neg49.4%
distribute-neg-in49.4%
pow249.4%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod49.4%
sqr-neg49.4%
sqrt-prod48.2%
add-sqr-sqrt49.4%
distribute-rgt-neg-in49.4%
metadata-eval49.4%
Applied egg-rr49.4%
flip-+49.3%
pow249.3%
unpow249.3%
Applied egg-rr49.3%
unpow249.3%
sqr-neg49.3%
rem-square-sqrt51.0%
fma-define51.0%
associate-*r*51.0%
fma-define51.0%
sub-neg51.0%
distribute-neg-out51.0%
fma-define51.0%
associate-*r*51.0%
fma-define51.0%
Simplified51.0%
clear-num51.0%
inv-pow51.0%
+-commutative51.0%
Applied egg-rr51.0%
unpow-151.0%
distribute-frac-neg51.0%
distribute-neg-frac251.0%
fma-define51.0%
associate-*l*51.0%
*-commutative51.0%
fma-define51.0%
*-commutative51.0%
sub-neg51.0%
+-commutative51.0%
fma-define51.0%
+-commutative51.0%
*-commutative51.0%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in c around 0 85.8%
Final simplification85.8%
(FPCore (a b c) :precision binary64 (* (/ 1.0 (* a -2.0)) (/ 1.0 (/ (+ (* 0.5 (/ b c)) (* -0.5 (/ a b))) a))))
double code(double a, double b, double c) {
return (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (-0.5 * (a / b))) / a));
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (1.0d0 / (a * (-2.0d0))) * (1.0d0 / (((0.5d0 * (b / c)) + ((-0.5d0) * (a / b))) / a))
end function
public static double code(double a, double b, double c) {
return (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (-0.5 * (a / b))) / a));
}
def code(a, b, c): return (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (-0.5 * (a / b))) / a))
function code(a, b, c) return Float64(Float64(1.0 / Float64(a * -2.0)) * Float64(1.0 / Float64(Float64(Float64(0.5 * Float64(b / c)) + Float64(-0.5 * Float64(a / b))) / a))) end
function tmp = code(a, b, c) tmp = (1.0 / (a * -2.0)) * (1.0 / (((0.5 * (b / c)) + (-0.5 * (a / b))) / a)); end
code[a_, b_, c_] := N[(N[(1.0 / N[(a * -2.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(N[(0.5 * N[(b / c), $MachinePrecision]), $MachinePrecision] + N[(-0.5 * N[(a / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{a \cdot -2} \cdot \frac{1}{\frac{0.5 \cdot \frac{b}{c} + -0.5 \cdot \frac{a}{b}}{a}}
\end{array}
Initial program 54.9%
Simplified54.9%
frac-2neg54.9%
div-inv54.9%
sub-neg54.9%
distribute-neg-in54.9%
pow254.9%
add-sqr-sqrt0.0%
sqrt-unprod1.6%
sqr-neg1.6%
sqrt-prod1.6%
add-sqr-sqrt1.6%
add-sqr-sqrt0.0%
sqrt-unprod54.9%
sqr-neg54.9%
sqrt-prod53.7%
add-sqr-sqrt54.9%
distribute-rgt-neg-in54.9%
metadata-eval54.9%
Applied egg-rr54.9%
flip-+54.8%
pow254.8%
unpow254.8%
Applied egg-rr54.8%
unpow254.8%
sqr-neg54.8%
rem-square-sqrt56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
sub-neg56.5%
distribute-neg-out56.5%
fma-define56.5%
associate-*r*56.5%
fma-define56.5%
Simplified56.5%
clear-num56.5%
inv-pow56.5%
+-commutative56.5%
Applied egg-rr56.5%
unpow-156.5%
distribute-frac-neg56.5%
distribute-neg-frac256.5%
fma-define56.5%
associate-*l*56.5%
*-commutative56.5%
fma-define56.5%
*-commutative56.5%
sub-neg56.5%
+-commutative56.5%
fma-define56.5%
+-commutative56.5%
*-commutative56.5%
associate-+r+99.1%
Simplified99.1%
Taylor expanded in a around 0 80.9%
Final simplification80.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(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 54.9%
*-commutative54.9%
Simplified54.9%
Taylor expanded in b around inf 64.7%
associate-*r/64.7%
mul-1-neg64.7%
Simplified64.7%
Final simplification64.7%
herbie shell --seed 2024115
(FPCore (a b c)
:name "Quadratic roots, narrow range"
:precision binary64
:pre (and (and (and (< 1.0536712127723509e-8 a) (< a 94906265.62425156)) (and (< 1.0536712127723509e-8 b) (< b 94906265.62425156))) (and (< 1.0536712127723509e-8 c) (< c 94906265.62425156)))
(/ (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)))