
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.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) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b c) :precision binary64 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))
double code(double a, double b, double c) {
return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.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) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function
public static double code(double a, double b, double c) {
return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}
def code(a, b, c): return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)
function code(a, b, c) return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a)) end
function tmp = code(a, b, c) tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a); end
code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a}
\end{array}
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045)
(*
(pow (- (- b) (sqrt t_0)) -1.0)
(pow (/ (* 3.0 a) (- (* b b) t_0)) -1.0))
(fma
(/
(fma
(* -1.0546875 (* a a))
(pow c 4.0)
(*
(fma (* -0.375 (* b b)) (* c c) (* -0.5625 (* (pow c 3.0) a)))
(* b b)))
(pow b 7.0))
a
(* (/ c b) -0.5)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = pow((-b - sqrt(t_0)), -1.0) * pow(((3.0 * a) / ((b * b) - t_0)), -1.0);
} else {
tmp = fma((fma((-1.0546875 * (a * a)), pow(c, 4.0), (fma((-0.375 * (b * b)), (c * c), (-0.5625 * (pow(c, 3.0) * a))) * (b * b))) / pow(b, 7.0)), a, ((c / b) * -0.5));
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64((Float64(Float64(-b) - sqrt(t_0)) ^ -1.0) * (Float64(Float64(3.0 * a) / Float64(Float64(b * b) - t_0)) ^ -1.0)); else tmp = fma(Float64(fma(Float64(-1.0546875 * Float64(a * a)), (c ^ 4.0), Float64(fma(Float64(-0.375 * Float64(b * b)), Float64(c * c), Float64(-0.5625 * Float64((c ^ 3.0) * a))) * Float64(b * b))) / (b ^ 7.0)), a, Float64(Float64(c / b) * -0.5)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(N[Power[N[((-b) - N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision] * N[Power[N[(N[(3.0 * a), $MachinePrecision] / N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(-1.0546875 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[Power[c, 4.0], $MachinePrecision] + N[(N[(N[(-0.375 * N[(b * b), $MachinePrecision]), $MachinePrecision] * N[(c * c), $MachinePrecision] + N[(-0.5625 * N[(N[Power[c, 3.0], $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[b, 7.0], $MachinePrecision]), $MachinePrecision] * a + N[(N[(c / b), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;{\left(\left(-b\right) - \sqrt{t\_0}\right)}^{-1} \cdot {\left(\frac{3 \cdot a}{b \cdot b - t\_0}\right)}^{-1}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\mathsf{fma}\left(-1.0546875 \cdot \left(a \cdot a\right), {c}^{4}, \mathsf{fma}\left(-0.375 \cdot \left(b \cdot b\right), c \cdot c, -0.5625 \cdot \left({c}^{3} \cdot a\right)\right) \cdot \left(b \cdot b\right)\right)}{{b}^{7}}, a, \frac{c}{b} \cdot -0.5\right)\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites83.2%
Applied rewrites84.5%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
Taylor expanded in a around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites93.2%
Taylor expanded in b around 0
Applied rewrites93.2%
Final simplification91.4%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* (/ c (* b b)) a))
(t_1 (* -9.0 (* c a)))
(t_2 (* t_1 0.5))
(t_3 (* (* c c) (* a a)))
(t_4 (fma t_3 27.0 (* (pow t_1 2.0) -0.25)))
(t_5 (fma (* (pow a 3.0) -27.0) (pow c 3.0) (* (* t_4 t_1) -0.5))))
(/
(/
(/
(*
(fma
-0.5
(/ (fma t_2 t_5 (* (pow t_4 2.0) 0.25)) (pow b 6.0))
(fma 0.5 (+ (/ t_4 (* b b)) (/ t_5 (pow b 4.0))) t_2))
b)
(*
(+
(fma
-3.0
t_0
(fma
-1.6875
(/ (* (pow c 3.0) (pow a 3.0)) (pow b 6.0))
(fma -1.125 (/ t_3 (pow b 4.0)) (* -1.5 t_0))))
3.0)
(* b b)))
a)
3.0)))
double code(double a, double b, double c) {
double t_0 = (c / (b * b)) * a;
double t_1 = -9.0 * (c * a);
double t_2 = t_1 * 0.5;
double t_3 = (c * c) * (a * a);
double t_4 = fma(t_3, 27.0, (pow(t_1, 2.0) * -0.25));
double t_5 = fma((pow(a, 3.0) * -27.0), pow(c, 3.0), ((t_4 * t_1) * -0.5));
return (((fma(-0.5, (fma(t_2, t_5, (pow(t_4, 2.0) * 0.25)) / pow(b, 6.0)), fma(0.5, ((t_4 / (b * b)) + (t_5 / pow(b, 4.0))), t_2)) * b) / ((fma(-3.0, t_0, fma(-1.6875, ((pow(c, 3.0) * pow(a, 3.0)) / pow(b, 6.0)), fma(-1.125, (t_3 / pow(b, 4.0)), (-1.5 * t_0)))) + 3.0) * (b * b))) / a) / 3.0;
}
function code(a, b, c) t_0 = Float64(Float64(c / Float64(b * b)) * a) t_1 = Float64(-9.0 * Float64(c * a)) t_2 = Float64(t_1 * 0.5) t_3 = Float64(Float64(c * c) * Float64(a * a)) t_4 = fma(t_3, 27.0, Float64((t_1 ^ 2.0) * -0.25)) t_5 = fma(Float64((a ^ 3.0) * -27.0), (c ^ 3.0), Float64(Float64(t_4 * t_1) * -0.5)) return Float64(Float64(Float64(Float64(fma(-0.5, Float64(fma(t_2, t_5, Float64((t_4 ^ 2.0) * 0.25)) / (b ^ 6.0)), fma(0.5, Float64(Float64(t_4 / Float64(b * b)) + Float64(t_5 / (b ^ 4.0))), t_2)) * b) / Float64(Float64(fma(-3.0, t_0, fma(-1.6875, Float64(Float64((c ^ 3.0) * (a ^ 3.0)) / (b ^ 6.0)), fma(-1.125, Float64(t_3 / (b ^ 4.0)), Float64(-1.5 * t_0)))) + 3.0) * Float64(b * b))) / a) / 3.0) end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(c / N[(b * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]}, Block[{t$95$1 = N[(-9.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * 0.5), $MachinePrecision]}, Block[{t$95$3 = N[(N[(c * c), $MachinePrecision] * N[(a * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$3 * 27.0 + N[(N[Power[t$95$1, 2.0], $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(N[Power[a, 3.0], $MachinePrecision] * -27.0), $MachinePrecision] * N[Power[c, 3.0], $MachinePrecision] + N[(N[(t$95$4 * t$95$1), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(N[(N[(-0.5 * N[(N[(t$95$2 * t$95$5 + N[(N[Power[t$95$4, 2.0], $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(t$95$4 / N[(b * b), $MachinePrecision]), $MachinePrecision] + N[(t$95$5 / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(N[(N[(-3.0 * t$95$0 + N[(-1.6875 * N[(N[(N[Power[c, 3.0], $MachinePrecision] * N[Power[a, 3.0], $MachinePrecision]), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision] + N[(-1.125 * N[(t$95$3 / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision] + N[(-1.5 * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 3.0), $MachinePrecision] * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{c}{b \cdot b} \cdot a\\
t_1 := -9 \cdot \left(c \cdot a\right)\\
t_2 := t\_1 \cdot 0.5\\
t_3 := \left(c \cdot c\right) \cdot \left(a \cdot a\right)\\
t_4 := \mathsf{fma}\left(t\_3, 27, {t\_1}^{2} \cdot -0.25\right)\\
t_5 := \mathsf{fma}\left({a}^{3} \cdot -27, {c}^{3}, \left(t\_4 \cdot t\_1\right) \cdot -0.5\right)\\
\frac{\frac{\frac{\mathsf{fma}\left(-0.5, \frac{\mathsf{fma}\left(t\_2, t\_5, {t\_4}^{2} \cdot 0.25\right)}{{b}^{6}}, \mathsf{fma}\left(0.5, \frac{t\_4}{b \cdot b} + \frac{t\_5}{{b}^{4}}, t\_2\right)\right) \cdot b}{\left(\mathsf{fma}\left(-3, t\_0, \mathsf{fma}\left(-1.6875, \frac{{c}^{3} \cdot {a}^{3}}{{b}^{6}}, \mathsf{fma}\left(-1.125, \frac{t\_3}{{b}^{4}}, -1.5 \cdot t\_0\right)\right)\right) + 3\right) \cdot \left(b \cdot b\right)}}{a}}{3}
\end{array}
\end{array}
Initial program 56.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites56.7%
Applied rewrites58.1%
Taylor expanded in b around inf
Applied rewrites90.1%
Taylor expanded in b around inf
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites90.3%
Final simplification90.3%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (* -9.0 (* c a)))
(t_1 (fma (* (* c c) (* a a)) 27.0 (* (pow t_0 2.0) -0.25)))
(t_2 (fma (* (pow a 3.0) -27.0) (pow c 3.0) (* (* t_1 t_0) -0.5)))
(t_3 (* t_0 0.5)))
(/
(/
(/
(*
(fma
-0.5
(/ (fma t_3 t_2 (* (pow t_1 2.0) 0.25)) (pow b 6.0))
(fma 0.5 (+ (/ t_1 (* b b)) (/ t_2 (pow b 4.0))) t_3))
b)
(fma
b
b
(fma
c
(fma
a
-4.5
(*
(fma
-1.6875
(* (/ c (pow b 4.0)) (pow a 3.0))
(/ (* -1.125 (* a a)) (* b b)))
c))
(* (* b b) 2.0))))
a)
3.0)))
double code(double a, double b, double c) {
double t_0 = -9.0 * (c * a);
double t_1 = fma(((c * c) * (a * a)), 27.0, (pow(t_0, 2.0) * -0.25));
double t_2 = fma((pow(a, 3.0) * -27.0), pow(c, 3.0), ((t_1 * t_0) * -0.5));
double t_3 = t_0 * 0.5;
return (((fma(-0.5, (fma(t_3, t_2, (pow(t_1, 2.0) * 0.25)) / pow(b, 6.0)), fma(0.5, ((t_1 / (b * b)) + (t_2 / pow(b, 4.0))), t_3)) * b) / fma(b, b, fma(c, fma(a, -4.5, (fma(-1.6875, ((c / pow(b, 4.0)) * pow(a, 3.0)), ((-1.125 * (a * a)) / (b * b))) * c)), ((b * b) * 2.0)))) / a) / 3.0;
}
function code(a, b, c) t_0 = Float64(-9.0 * Float64(c * a)) t_1 = fma(Float64(Float64(c * c) * Float64(a * a)), 27.0, Float64((t_0 ^ 2.0) * -0.25)) t_2 = fma(Float64((a ^ 3.0) * -27.0), (c ^ 3.0), Float64(Float64(t_1 * t_0) * -0.5)) t_3 = Float64(t_0 * 0.5) return Float64(Float64(Float64(Float64(fma(-0.5, Float64(fma(t_3, t_2, Float64((t_1 ^ 2.0) * 0.25)) / (b ^ 6.0)), fma(0.5, Float64(Float64(t_1 / Float64(b * b)) + Float64(t_2 / (b ^ 4.0))), t_3)) * b) / fma(b, b, fma(c, fma(a, -4.5, Float64(fma(-1.6875, Float64(Float64(c / (b ^ 4.0)) * (a ^ 3.0)), Float64(Float64(-1.125 * Float64(a * a)) / Float64(b * b))) * c)), Float64(Float64(b * b) * 2.0)))) / a) / 3.0) end
code[a_, b_, c_] := Block[{t$95$0 = N[(-9.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(c * c), $MachinePrecision] * N[(a * a), $MachinePrecision]), $MachinePrecision] * 27.0 + N[(N[Power[t$95$0, 2.0], $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Power[a, 3.0], $MachinePrecision] * -27.0), $MachinePrecision] * N[Power[c, 3.0], $MachinePrecision] + N[(N[(t$95$1 * t$95$0), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$0 * 0.5), $MachinePrecision]}, N[(N[(N[(N[(N[(-0.5 * N[(N[(t$95$3 * t$95$2 + N[(N[Power[t$95$1, 2.0], $MachinePrecision] * 0.25), $MachinePrecision]), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(t$95$1 / N[(b * b), $MachinePrecision]), $MachinePrecision] + N[(t$95$2 / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] / N[(b * b + N[(c * N[(a * -4.5 + N[(N[(-1.6875 * N[(N[(c / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision] * N[Power[a, 3.0], $MachinePrecision]), $MachinePrecision] + N[(N[(-1.125 * N[(a * a), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] + N[(N[(b * b), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := -9 \cdot \left(c \cdot a\right)\\
t_1 := \mathsf{fma}\left(\left(c \cdot c\right) \cdot \left(a \cdot a\right), 27, {t\_0}^{2} \cdot -0.25\right)\\
t_2 := \mathsf{fma}\left({a}^{3} \cdot -27, {c}^{3}, \left(t\_1 \cdot t\_0\right) \cdot -0.5\right)\\
t_3 := t\_0 \cdot 0.5\\
\frac{\frac{\frac{\mathsf{fma}\left(-0.5, \frac{\mathsf{fma}\left(t\_3, t\_2, {t\_1}^{2} \cdot 0.25\right)}{{b}^{6}}, \mathsf{fma}\left(0.5, \frac{t\_1}{b \cdot b} + \frac{t\_2}{{b}^{4}}, t\_3\right)\right) \cdot b}{\mathsf{fma}\left(b, b, \mathsf{fma}\left(c, \mathsf{fma}\left(a, -4.5, \mathsf{fma}\left(-1.6875, \frac{c}{{b}^{4}} \cdot {a}^{3}, \frac{-1.125 \cdot \left(a \cdot a\right)}{b \cdot b}\right) \cdot c\right), \left(b \cdot b\right) \cdot 2\right)\right)}}{a}}{3}
\end{array}
\end{array}
Initial program 56.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites56.7%
Applied rewrites58.1%
Taylor expanded in b around inf
Applied rewrites90.1%
Taylor expanded in c around 0
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites90.2%
Final simplification90.2%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b)))
(t_1 (* 6.75 (* c c)))
(t_2 (* t_1 c))
(t_3 (* (pow c 3.0) -27.0)))
(/
(/
(/
(*
(*
(fma
a
(fma
0.5
(* 6.75 (/ (* c c) (* b b)))
(*
(fma
0.5
(fma 4.5 (/ t_2 (pow b 4.0)) (/ t_3 (pow b 4.0)))
(/
(*
(* (fma 0.25 (pow t_1 2.0) (* (* (fma 4.5 t_2 t_3) c) -4.5)) a)
-0.5)
(pow b 6.0)))
a))
(* -4.5 c))
a)
b)
(fma b b (+ (* (sqrt t_0) b) t_0)))
a)
3.0)))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double t_1 = 6.75 * (c * c);
double t_2 = t_1 * c;
double t_3 = pow(c, 3.0) * -27.0;
return ((((fma(a, fma(0.5, (6.75 * ((c * c) / (b * b))), (fma(0.5, fma(4.5, (t_2 / pow(b, 4.0)), (t_3 / pow(b, 4.0))), (((fma(0.25, pow(t_1, 2.0), ((fma(4.5, t_2, t_3) * c) * -4.5)) * a) * -0.5) / pow(b, 6.0))) * a)), (-4.5 * c)) * a) * b) / fma(b, b, ((sqrt(t_0) * b) + t_0))) / a) / 3.0;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) t_1 = Float64(6.75 * Float64(c * c)) t_2 = Float64(t_1 * c) t_3 = Float64((c ^ 3.0) * -27.0) return Float64(Float64(Float64(Float64(Float64(fma(a, fma(0.5, Float64(6.75 * Float64(Float64(c * c) / Float64(b * b))), Float64(fma(0.5, fma(4.5, Float64(t_2 / (b ^ 4.0)), Float64(t_3 / (b ^ 4.0))), Float64(Float64(Float64(fma(0.25, (t_1 ^ 2.0), Float64(Float64(fma(4.5, t_2, t_3) * c) * -4.5)) * a) * -0.5) / (b ^ 6.0))) * a)), Float64(-4.5 * c)) * a) * b) / fma(b, b, Float64(Float64(sqrt(t_0) * b) + t_0))) / a) / 3.0) end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(6.75 * N[(c * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * c), $MachinePrecision]}, Block[{t$95$3 = N[(N[Power[c, 3.0], $MachinePrecision] * -27.0), $MachinePrecision]}, N[(N[(N[(N[(N[(N[(a * N[(0.5 * N[(6.75 * N[(N[(c * c), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(0.5 * N[(4.5 * N[(t$95$2 / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision] + N[(t$95$3 / N[Power[b, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(0.25 * N[Power[t$95$1, 2.0], $MachinePrecision] + N[(N[(N[(4.5 * t$95$2 + t$95$3), $MachinePrecision] * c), $MachinePrecision] * -4.5), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * -0.5), $MachinePrecision] / N[Power[b, 6.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] + N[(-4.5 * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * b), $MachinePrecision] / N[(b * b + N[(N[(N[Sqrt[t$95$0], $MachinePrecision] * b), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
t_1 := 6.75 \cdot \left(c \cdot c\right)\\
t_2 := t\_1 \cdot c\\
t_3 := {c}^{3} \cdot -27\\
\frac{\frac{\frac{\left(\mathsf{fma}\left(a, \mathsf{fma}\left(0.5, 6.75 \cdot \frac{c \cdot c}{b \cdot b}, \mathsf{fma}\left(0.5, \mathsf{fma}\left(4.5, \frac{t\_2}{{b}^{4}}, \frac{t\_3}{{b}^{4}}\right), \frac{\left(\mathsf{fma}\left(0.25, {t\_1}^{2}, \left(\mathsf{fma}\left(4.5, t\_2, t\_3\right) \cdot c\right) \cdot -4.5\right) \cdot a\right) \cdot -0.5}{{b}^{6}}\right) \cdot a\right), -4.5 \cdot c\right) \cdot a\right) \cdot b}{\mathsf{fma}\left(b, b, \sqrt{t\_0} \cdot b + t\_0\right)}}{a}}{3}
\end{array}
\end{array}
Initial program 56.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites56.7%
Applied rewrites58.1%
Taylor expanded in b around inf
Applied rewrites90.1%
Taylor expanded in a around 0
Applied rewrites90.2%
Final simplification90.2%
(FPCore (a b c)
:precision binary64
(/
(pow a -1.0)
(/
(fma
(fma
(fma
(- c)
(/ (* -1.6875 (* a a)) (pow b 5.0))
(* (/ a (pow b 3.0)) 1.125))
c
(/ 1.5 b))
c
(* -2.0 (/ b a)))
c)))
double code(double a, double b, double c) {
return pow(a, -1.0) / (fma(fma(fma(-c, ((-1.6875 * (a * a)) / pow(b, 5.0)), ((a / pow(b, 3.0)) * 1.125)), c, (1.5 / b)), c, (-2.0 * (b / a))) / c);
}
function code(a, b, c) return Float64((a ^ -1.0) / Float64(fma(fma(fma(Float64(-c), Float64(Float64(-1.6875 * Float64(a * a)) / (b ^ 5.0)), Float64(Float64(a / (b ^ 3.0)) * 1.125)), c, Float64(1.5 / b)), c, Float64(-2.0 * Float64(b / a))) / c)) end
code[a_, b_, c_] := N[(N[Power[a, -1.0], $MachinePrecision] / N[(N[(N[(N[((-c) * N[(N[(-1.6875 * N[(a * a), $MachinePrecision]), $MachinePrecision] / N[Power[b, 5.0], $MachinePrecision]), $MachinePrecision] + N[(N[(a / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * 1.125), $MachinePrecision]), $MachinePrecision] * c + N[(1.5 / b), $MachinePrecision]), $MachinePrecision] * c + N[(-2.0 * N[(b / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{a}^{-1}}{\frac{\mathsf{fma}\left(\mathsf{fma}\left(\mathsf{fma}\left(-c, \frac{-1.6875 \cdot \left(a \cdot a\right)}{{b}^{5}}, \frac{a}{{b}^{3}} \cdot 1.125\right), c, \frac{1.5}{b}\right), c, -2 \cdot \frac{b}{a}\right)}{c}}
\end{array}
Initial program 56.7%
lift-/.f64N/A
div-invN/A
lift-+.f64N/A
flip3-+N/A
clear-numN/A
lift-*.f64N/A
associate-/l/N/A
frac-timesN/A
Applied rewrites56.7%
Taylor expanded in c around 0
Applied rewrites89.9%
Taylor expanded in a around 0
Applied rewrites89.9%
Final simplification89.9%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045)
(*
(pow (- (- b) (sqrt t_0)) -1.0)
(pow (/ (* 3.0 a) (- (* b b) t_0)) -1.0))
(/
1.0
(/
(fma
c
(fma (* -3.0 c) (* (/ (* a a) (pow b 3.0)) -0.375) (* (/ a b) 1.5))
(* -2.0 b))
c)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = pow((-b - sqrt(t_0)), -1.0) * pow(((3.0 * a) / ((b * b) - t_0)), -1.0);
} else {
tmp = 1.0 / (fma(c, fma((-3.0 * c), (((a * a) / pow(b, 3.0)) * -0.375), ((a / b) * 1.5)), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64((Float64(Float64(-b) - sqrt(t_0)) ^ -1.0) * (Float64(Float64(3.0 * a) / Float64(Float64(b * b) - t_0)) ^ -1.0)); else tmp = Float64(1.0 / Float64(fma(c, fma(Float64(-3.0 * c), Float64(Float64(Float64(a * a) / (b ^ 3.0)) * -0.375), Float64(Float64(a / b) * 1.5)), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(N[Power[N[((-b) - N[Sqrt[t$95$0], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision] * N[Power[N[(N[(3.0 * a), $MachinePrecision] / N[(N[(b * b), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(c * N[(N[(-3.0 * c), $MachinePrecision] * N[(N[(N[(a * a), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * -0.375), $MachinePrecision] + N[(N[(a / b), $MachinePrecision] * 1.5), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;{\left(\left(-b\right) - \sqrt{t\_0}\right)}^{-1} \cdot {\left(\frac{3 \cdot a}{b \cdot b - t\_0}\right)}^{-1}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(c, \mathsf{fma}\left(-3 \cdot c, \frac{a \cdot a}{{b}^{3}} \cdot -0.375, \frac{a}{b} \cdot 1.5\right), -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites83.2%
Applied rewrites84.5%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in c around 0
lower-/.f64N/A
Applied rewrites91.5%
Final simplification90.0%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045)
(/ 1.0 (/ 3.0 (/ (/ (- t_0 (* b b)) (+ (sqrt t_0) b)) a)))
(/
1.0
(/
(fma
c
(fma (* -3.0 c) (* (/ (* a a) (pow b 3.0)) -0.375) (* (/ a b) 1.5))
(* -2.0 b))
c)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = 1.0 / (3.0 / (((t_0 - (b * b)) / (sqrt(t_0) + b)) / a));
} else {
tmp = 1.0 / (fma(c, fma((-3.0 * c), (((a * a) / pow(b, 3.0)) * -0.375), ((a / b) * 1.5)), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64(1.0 / Float64(3.0 / Float64(Float64(Float64(t_0 - Float64(b * b)) / Float64(sqrt(t_0) + b)) / a))); else tmp = Float64(1.0 / Float64(fma(c, fma(Float64(-3.0 * c), Float64(Float64(Float64(a * a) / (b ^ 3.0)) * -0.375), Float64(Float64(a / b) * 1.5)), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(1.0 / N[(3.0 / N[(N[(N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[t$95$0], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(c * N[(N[(-3.0 * c), $MachinePrecision] * N[(N[(N[(a * a), $MachinePrecision] / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * -0.375), $MachinePrecision] + N[(N[(a / b), $MachinePrecision] * 1.5), $MachinePrecision]), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;\frac{1}{\frac{3}{\frac{\frac{t\_0 - b \cdot b}{\sqrt{t\_0} + b}}{a}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(c, \mathsf{fma}\left(-3 \cdot c, \frac{a \cdot a}{{b}^{3}} \cdot -0.375, \frac{a}{b} \cdot 1.5\right), -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6483.3
Applied rewrites83.3%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-*.f64N/A
lower-+.f6484.5
Applied rewrites84.5%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in c around 0
lower-/.f64N/A
Applied rewrites91.5%
Final simplification90.0%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045)
(/ 1.0 (/ 3.0 (/ (/ (- t_0 (* b b)) (+ (sqrt t_0) b)) a)))
(/
1.0
(fma
-2.0
(/ b c)
(* (fma -3.0 (* (* (/ c (pow b 3.0)) -0.375) a) (/ 1.5 b)) a))))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = 1.0 / (3.0 / (((t_0 - (b * b)) / (sqrt(t_0) + b)) / a));
} else {
tmp = 1.0 / fma(-2.0, (b / c), (fma(-3.0, (((c / pow(b, 3.0)) * -0.375) * a), (1.5 / b)) * a));
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64(1.0 / Float64(3.0 / Float64(Float64(Float64(t_0 - Float64(b * b)) / Float64(sqrt(t_0) + b)) / a))); else tmp = Float64(1.0 / fma(-2.0, Float64(b / c), Float64(fma(-3.0, Float64(Float64(Float64(c / (b ^ 3.0)) * -0.375) * a), Float64(1.5 / b)) * a))); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(1.0 / N[(3.0 / N[(N[(N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[t$95$0], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(-2.0 * N[(b / c), $MachinePrecision] + N[(N[(-3.0 * N[(N[(N[(c / N[Power[b, 3.0], $MachinePrecision]), $MachinePrecision] * -0.375), $MachinePrecision] * a), $MachinePrecision] + N[(1.5 / b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;\frac{1}{\frac{3}{\frac{\frac{t\_0 - b \cdot b}{\sqrt{t\_0} + b}}{a}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(-2, \frac{b}{c}, \mathsf{fma}\left(-3, \left(\frac{c}{{b}^{3}} \cdot -0.375\right) \cdot a, \frac{1.5}{b}\right) \cdot a\right)}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6483.3
Applied rewrites83.3%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-*.f64N/A
lower-+.f6484.5
Applied rewrites84.5%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in a around 0
lower-fma.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
lower-pow.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6491.5
Applied rewrites91.5%
Final simplification90.0%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))) (t_1 (sqrt t_0)))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.0028)
(/ (* (/ 0.3333333333333333 a) (- t_0 (* b b))) (+ t_1 b))
(/
(/
(/
(* (* (fma (* c 0.5) (* (/ (* a a) (* b b)) 6.75) (* -4.5 a)) c) b)
(fma b b (+ (* t_1 b) t_0)))
a)
3.0))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double t_1 = sqrt(t_0);
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.0028) {
tmp = ((0.3333333333333333 / a) * (t_0 - (b * b))) / (t_1 + b);
} else {
tmp = ((((fma((c * 0.5), (((a * a) / (b * b)) * 6.75), (-4.5 * a)) * c) * b) / fma(b, b, ((t_1 * b) + t_0))) / a) / 3.0;
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) t_1 = sqrt(t_0) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.0028) tmp = Float64(Float64(Float64(0.3333333333333333 / a) * Float64(t_0 - Float64(b * b))) / Float64(t_1 + b)); else tmp = Float64(Float64(Float64(Float64(Float64(fma(Float64(c * 0.5), Float64(Float64(Float64(a * a) / Float64(b * b)) * 6.75), Float64(-4.5 * a)) * c) * b) / fma(b, b, Float64(Float64(t_1 * b) + t_0))) / a) / 3.0); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[t$95$0], $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.0028], N[(N[(N[(0.3333333333333333 / a), $MachinePrecision] * N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 + b), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(c * 0.5), $MachinePrecision] * N[(N[(N[(a * a), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision] * 6.75), $MachinePrecision] + N[(-4.5 * a), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * b), $MachinePrecision] / N[(b * b + N[(N[(t$95$1 * b), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
t_1 := \sqrt{t\_0}\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.0028:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{a} \cdot \left(t\_0 - b \cdot b\right)}{t\_1 + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{\left(\mathsf{fma}\left(c \cdot 0.5, \frac{a \cdot a}{b \cdot b} \cdot 6.75, -4.5 \cdot a\right) \cdot c\right) \cdot b}{\mathsf{fma}\left(b, b, t\_1 \cdot b + t\_0\right)}}{a}}{3}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.00279999999999999997Initial program 79.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites79.7%
Applied rewrites81.3%
if -0.00279999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 46.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites46.8%
Applied rewrites48.5%
Taylor expanded in b around inf
Applied rewrites94.3%
Taylor expanded in c around 0
Applied rewrites88.5%
Final simplification86.4%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))) (t_1 (sqrt t_0)))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.0028)
(/ (* (/ 0.3333333333333333 a) (- t_0 (* b b))) (+ t_1 b))
(/
(/
(/
(* (* (fma (* a 0.5) (* 6.75 (/ (* c c) (* b b))) (* -4.5 c)) a) b)
(fma b b (+ (* t_1 b) t_0)))
a)
3.0))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double t_1 = sqrt(t_0);
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.0028) {
tmp = ((0.3333333333333333 / a) * (t_0 - (b * b))) / (t_1 + b);
} else {
tmp = ((((fma((a * 0.5), (6.75 * ((c * c) / (b * b))), (-4.5 * c)) * a) * b) / fma(b, b, ((t_1 * b) + t_0))) / a) / 3.0;
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) t_1 = sqrt(t_0) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.0028) tmp = Float64(Float64(Float64(0.3333333333333333 / a) * Float64(t_0 - Float64(b * b))) / Float64(t_1 + b)); else tmp = Float64(Float64(Float64(Float64(Float64(fma(Float64(a * 0.5), Float64(6.75 * Float64(Float64(c * c) / Float64(b * b))), Float64(-4.5 * c)) * a) * b) / fma(b, b, Float64(Float64(t_1 * b) + t_0))) / a) / 3.0); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[t$95$0], $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.0028], N[(N[(N[(0.3333333333333333 / a), $MachinePrecision] * N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 + b), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(a * 0.5), $MachinePrecision] * N[(6.75 * N[(N[(c * c), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-4.5 * c), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * b), $MachinePrecision] / N[(b * b + N[(N[(t$95$1 * b), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision] / 3.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
t_1 := \sqrt{t\_0}\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.0028:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{a} \cdot \left(t\_0 - b \cdot b\right)}{t\_1 + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{\frac{\left(\mathsf{fma}\left(a \cdot 0.5, 6.75 \cdot \frac{c \cdot c}{b \cdot b}, -4.5 \cdot c\right) \cdot a\right) \cdot b}{\mathsf{fma}\left(b, b, t\_1 \cdot b + t\_0\right)}}{a}}{3}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.00279999999999999997Initial program 79.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites79.7%
Applied rewrites81.3%
if -0.00279999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 46.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites46.8%
Applied rewrites48.5%
Taylor expanded in b around inf
Applied rewrites94.3%
Taylor expanded in a around 0
Applied rewrites88.5%
Final simplification86.4%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.0028)
(/ (* (/ 0.3333333333333333 a) (- t_0 (* b b))) (+ (sqrt t_0) b))
(/ 1.0 (/ (fma 1.5 (* (/ c b) a) (* -2.0 b)) c)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.0028) {
tmp = ((0.3333333333333333 / a) * (t_0 - (b * b))) / (sqrt(t_0) + b);
} else {
tmp = 1.0 / (fma(1.5, ((c / b) * a), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.0028) tmp = Float64(Float64(Float64(0.3333333333333333 / a) * Float64(t_0 - Float64(b * b))) / Float64(sqrt(t_0) + b)); else tmp = Float64(1.0 / Float64(fma(1.5, Float64(Float64(c / b) * a), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.0028], N[(N[(N[(0.3333333333333333 / a), $MachinePrecision] * N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Sqrt[t$95$0], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(1.5 * N[(N[(c / b), $MachinePrecision] * a), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.0028:\\
\;\;\;\;\frac{\frac{0.3333333333333333}{a} \cdot \left(t\_0 - b \cdot b\right)}{\sqrt{t\_0} + b}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(1.5, \frac{c}{b} \cdot a, -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.00279999999999999997Initial program 79.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites79.7%
Applied rewrites81.3%
if -0.00279999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 46.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6446.9
Applied rewrites46.8%
Taylor expanded in c around 0
lower-/.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6488.5
Applied rewrites88.5%
Final simplification86.3%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.0028)
(/ (/ (- t_0 (* b b)) (* (+ (sqrt t_0) b) a)) 3.0)
(/ 1.0 (/ (fma 1.5 (* (/ c b) a) (* -2.0 b)) c)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.0028) {
tmp = ((t_0 - (b * b)) / ((sqrt(t_0) + b) * a)) / 3.0;
} else {
tmp = 1.0 / (fma(1.5, ((c / b) * a), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.0028) tmp = Float64(Float64(Float64(t_0 - Float64(b * b)) / Float64(Float64(sqrt(t_0) + b) * a)) / 3.0); else tmp = Float64(1.0 / Float64(fma(1.5, Float64(Float64(c / b) * a), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.0028], N[(N[(N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sqrt[t$95$0], $MachinePrecision] + b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision] / 3.0), $MachinePrecision], N[(1.0 / N[(N[(1.5 * N[(N[(c / b), $MachinePrecision] * a), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.0028:\\
\;\;\;\;\frac{\frac{t\_0 - b \cdot b}{\left(\sqrt{t\_0} + b\right) \cdot a}}{3}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(1.5, \frac{c}{b} \cdot a, -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.00279999999999999997Initial program 79.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites79.7%
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/l/N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-+.f6481.3
Applied rewrites81.3%
if -0.00279999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 46.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6446.9
Applied rewrites46.8%
Taylor expanded in c around 0
lower-/.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6488.5
Applied rewrites88.5%
Final simplification86.3%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (fma (* -3.0 c) a (* b b))))
(if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.0028)
(/ (- t_0 (* b b)) (* (+ (sqrt t_0) b) (* 3.0 a)))
(/ 1.0 (/ (fma 1.5 (* (/ c b) a) (* -2.0 b)) c)))))
double code(double a, double b, double c) {
double t_0 = fma((-3.0 * c), a, (b * b));
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.0028) {
tmp = (t_0 - (b * b)) / ((sqrt(t_0) + b) * (3.0 * a));
} else {
tmp = 1.0 / (fma(1.5, ((c / b) * a), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) t_0 = fma(Float64(-3.0 * c), a, Float64(b * b)) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.0028) tmp = Float64(Float64(t_0 - Float64(b * b)) / Float64(Float64(sqrt(t_0) + b) * Float64(3.0 * a))); else tmp = Float64(1.0 / Float64(fma(1.5, Float64(Float64(c / b) * a), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := Block[{t$95$0 = N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.0028], N[(N[(t$95$0 - N[(b * b), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Sqrt[t$95$0], $MachinePrecision] + b), $MachinePrecision] * N[(3.0 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(1.5 * N[(N[(c / b), $MachinePrecision] * a), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)\\
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.0028:\\
\;\;\;\;\frac{t\_0 - b \cdot b}{\left(\sqrt{t\_0} + b\right) \cdot \left(3 \cdot a\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(1.5, \frac{c}{b} \cdot a, -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.00279999999999999997Initial program 79.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
lower-/.f64N/A
Applied rewrites79.7%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift--.f64N/A
flip--N/A
associate-/l/N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
Applied rewrites81.2%
if -0.00279999999999999997 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 46.9%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6446.9
Applied rewrites46.8%
Taylor expanded in c around 0
lower-/.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6488.5
Applied rewrites88.5%
Final simplification86.3%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045) (/ (- (sqrt (fma (* -3.0 a) c (* b b))) b) (* 3.0 a)) (/ 1.0 (/ (fma 1.5 (* (/ c b) a) (* -2.0 b)) c))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = (sqrt(fma((-3.0 * a), c, (b * b))) - b) / (3.0 * a);
} else {
tmp = 1.0 / (fma(1.5, ((c / b) * a), (-2.0 * b)) / c);
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64(Float64(sqrt(fma(Float64(-3.0 * a), c, Float64(b * b))) - b) / Float64(3.0 * a)); else tmp = Float64(1.0 / Float64(fma(1.5, Float64(Float64(c / b) * a), Float64(-2.0 * b)) / c)); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(N[(N[Sqrt[N[(N[(-3.0 * a), $MachinePrecision] * c + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[(1.5 * N[(N[(c / b), $MachinePrecision] * a), $MachinePrecision] + N[(-2.0 * b), $MachinePrecision]), $MachinePrecision] / c), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-3 \cdot a, c, b \cdot b\right)} - b}{3 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{\mathsf{fma}\left(1.5, \frac{c}{b} \cdot a, -2 \cdot b\right)}{c}}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval83.3
Applied rewrites83.3%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in c around 0
lower-/.f64N/A
+-commutativeN/A
lower-fma.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower-*.f6486.6
Applied rewrites86.6%
Final simplification85.9%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045) (/ (- (sqrt (fma (* -3.0 a) c (* b b))) b) (* 3.0 a)) (/ 1.0 (fma 1.5 (/ a b) (* (/ b c) -2.0)))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = (sqrt(fma((-3.0 * a), c, (b * b))) - b) / (3.0 * a);
} else {
tmp = 1.0 / fma(1.5, (a / b), ((b / c) * -2.0));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64(Float64(sqrt(fma(Float64(-3.0 * a), c, Float64(b * b))) - b) / Float64(3.0 * a)); else tmp = Float64(1.0 / fma(1.5, Float64(a / b), Float64(Float64(b / c) * -2.0))); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(N[(N[Sqrt[N[(N[(-3.0 * a), $MachinePrecision] * c + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(1.5 * N[(a / b), $MachinePrecision] + N[(N[(b / c), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-3 \cdot a, c, b \cdot b\right)} - b}{3 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(1.5, \frac{a}{b}, \frac{b}{c} \cdot -2\right)}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lift-*.f64N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
metadata-eval83.3
Applied rewrites83.3%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f6486.6
Applied rewrites86.6%
Final simplification85.9%
(FPCore (a b c) :precision binary64 (if (<= (/ (- (sqrt (- (* b b) (* (* 3.0 a) c))) b) (* 3.0 a)) -0.045) (* (- (sqrt (fma (* -3.0 c) a (* b b))) b) (/ 0.3333333333333333 a)) (/ 1.0 (fma 1.5 (/ a b) (* (/ b c) -2.0)))))
double code(double a, double b, double c) {
double tmp;
if (((sqrt(((b * b) - ((3.0 * a) * c))) - b) / (3.0 * a)) <= -0.045) {
tmp = (sqrt(fma((-3.0 * c), a, (b * b))) - b) * (0.3333333333333333 / a);
} else {
tmp = 1.0 / fma(1.5, (a / b), ((b / c) * -2.0));
}
return tmp;
}
function code(a, b, c) tmp = 0.0 if (Float64(Float64(sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c))) - b) / Float64(3.0 * a)) <= -0.045) tmp = Float64(Float64(sqrt(fma(Float64(-3.0 * c), a, Float64(b * b))) - b) * Float64(0.3333333333333333 / a)); else tmp = Float64(1.0 / fma(1.5, Float64(a / b), Float64(Float64(b / c) * -2.0))); end return tmp end
code[a_, b_, c_] := If[LessEqual[N[(N[(N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision], -0.045], N[(N[(N[Sqrt[N[(N[(-3.0 * c), $MachinePrecision] * a + N[(b * b), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision] * N[(0.3333333333333333 / a), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(1.5 * N[(a / b), $MachinePrecision] + N[(N[(b / c), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c} - b}{3 \cdot a} \leq -0.045:\\
\;\;\;\;\left(\sqrt{\mathsf{fma}\left(-3 \cdot c, a, b \cdot b\right)} - b\right) \cdot \frac{0.3333333333333333}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(1.5, \frac{a}{b}, \frac{b}{c} \cdot -2\right)}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -0.044999999999999998Initial program 83.2%
lift-/.f64N/A
clear-numN/A
associate-/r/N/A
lower-*.f64N/A
lift-*.f64N/A
associate-/r*N/A
lower-/.f64N/A
metadata-eval83.3
lift-+.f64N/A
+-commutativeN/A
lift-neg.f64N/A
unsub-negN/A
lower--.f6483.3
Applied rewrites83.3%
if -0.044999999999999998 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) Initial program 49.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6449.7
Applied rewrites49.6%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f6486.6
Applied rewrites86.6%
Final simplification85.9%
(FPCore (a b c) :precision binary64 (/ 1.0 (fma 1.5 (/ a b) (* (/ b c) -2.0))))
double code(double a, double b, double c) {
return 1.0 / fma(1.5, (a / b), ((b / c) * -2.0));
}
function code(a, b, c) return Float64(1.0 / fma(1.5, Float64(a / b), Float64(Float64(b / c) * -2.0))) end
code[a_, b_, c_] := N[(1.0 / N[(1.5 * N[(a / b), $MachinePrecision] + N[(N[(b / c), $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\mathsf{fma}\left(1.5, \frac{a}{b}, \frac{b}{c} \cdot -2\right)}
\end{array}
Initial program 56.7%
lift-/.f64N/A
lift-*.f64N/A
associate-/l/N/A
clear-numN/A
lower-/.f64N/A
lower-/.f64N/A
lower-/.f6456.8
Applied rewrites56.7%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower-*.f64N/A
lower-/.f6480.7
Applied rewrites80.7%
Final simplification80.7%
(FPCore (a b c) :precision binary64 (* (/ c b) -0.5))
double code(double a, double b, double c) {
return (c / b) * -0.5;
}
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) * (-0.5d0)
end function
public static double code(double a, double b, double c) {
return (c / b) * -0.5;
}
def code(a, b, c): return (c / b) * -0.5
function code(a, b, c) return Float64(Float64(c / b) * -0.5) end
function tmp = code(a, b, c) tmp = (c / b) * -0.5; end
code[a_, b_, c_] := N[(N[(c / b), $MachinePrecision] * -0.5), $MachinePrecision]
\begin{array}{l}
\\
\frac{c}{b} \cdot -0.5
\end{array}
Initial program 56.7%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
lower-/.f6463.0
Applied rewrites63.0%
(FPCore (a b c) :precision binary64 (* (/ -0.5 b) c))
double code(double a, double b, double c) {
return (-0.5 / b) * c;
}
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) * c
end function
public static double code(double a, double b, double c) {
return (-0.5 / b) * c;
}
def code(a, b, c): return (-0.5 / b) * c
function code(a, b, c) return Float64(Float64(-0.5 / b) * c) end
function tmp = code(a, b, c) tmp = (-0.5 / b) * c; end
code[a_, b_, c_] := N[(N[(-0.5 / b), $MachinePrecision] * c), $MachinePrecision]
\begin{array}{l}
\\
\frac{-0.5}{b} \cdot c
\end{array}
Initial program 56.7%
Taylor expanded in c around 0
*-commutativeN/A
lower-*.f64N/A
lower-/.f6463.0
Applied rewrites63.0%
Applied rewrites62.9%
Final simplification62.9%
herbie shell --seed 2024272
(FPCore (a b c)
:name "Cubic critical, 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) (* (* 3.0 a) c)))) (* 3.0 a)))