
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c) :precision binary64 (+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
real(8) function code(x, y, z, t, a, b, c)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = (((x * y) + ((z * t) / 16.0d0)) - ((a * b) / 4.0d0)) + c
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c;
}
def code(x, y, z, t, a, b, c): return (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c
function code(x, y, z, t, a, b, c) return Float64(Float64(Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) - Float64(Float64(a * b) / 4.0)) + c) end
function tmp = code(x, y, z, t, a, b, c) tmp = (((x * y) + ((z * t) / 16.0)) - ((a * b) / 4.0)) + c; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision] - N[(N[(a * b), $MachinePrecision] / 4.0), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x \cdot y + \frac{z \cdot t}{16}\right) - \frac{a \cdot b}{4}\right) + c
\end{array}
(FPCore (x y z t a b c) :precision binary64 (+ (fma (* t 0.0625) z (fma y x (* (* b a) -0.25))) c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return fma((t * 0.0625), z, fma(y, x, ((b * a) * -0.25))) + c;
}
function code(x, y, z, t, a, b, c) return Float64(fma(Float64(t * 0.0625), z, fma(y, x, Float64(Float64(b * a) * -0.25))) + c) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(N[(N[(t * 0.0625), $MachinePrecision] * z + N[(y * x + N[(N[(b * a), $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(t \cdot 0.0625, z, \mathsf{fma}\left(y, x, \left(b \cdot a\right) \cdot -0.25\right)\right) + c
\end{array}
Initial program 97.3%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites98.4%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* z t) 0.0625 (* x y))) (t_2 (+ (* x y) (/ (* z t) 16.0))))
(if (<= t_2 -1e+132)
t_1
(if (<= t_2 -5e+64)
(fma x y c)
(if (<= t_2 5e+119) (fma -0.25 (* a b) c) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = fma((z * t), 0.0625, (x * y));
double t_2 = (x * y) + ((z * t) / 16.0);
double tmp;
if (t_2 <= -1e+132) {
tmp = t_1;
} else if (t_2 <= -5e+64) {
tmp = fma(x, y, c);
} else if (t_2 <= 5e+119) {
tmp = fma(-0.25, (a * b), c);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = fma(Float64(z * t), 0.0625, Float64(x * y)) t_2 = Float64(Float64(x * y) + Float64(Float64(z * t) / 16.0)) tmp = 0.0 if (t_2 <= -1e+132) tmp = t_1; elseif (t_2 <= -5e+64) tmp = fma(x, y, c); elseif (t_2 <= 5e+119) tmp = fma(-0.25, Float64(a * b), c); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(z * t), $MachinePrecision] * 0.0625 + N[(x * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] + N[(N[(z * t), $MachinePrecision] / 16.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+132], t$95$1, If[LessEqual[t$95$2, -5e+64], N[(x * y + c), $MachinePrecision], If[LessEqual[t$95$2, 5e+119], N[(-0.25 * N[(a * b), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z \cdot t, 0.0625, x \cdot y\right)\\
t_2 := x \cdot y + \frac{z \cdot t}{16}\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+132}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{+64}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+119}:\\
\;\;\;\;\mathsf{fma}\left(-0.25, a \cdot b, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) #s(literal 16 binary64))) < -9.99999999999999991e131 or 4.9999999999999999e119 < (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) #s(literal 16 binary64))) Initial program 95.2%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6487.4
Applied rewrites87.4%
Taylor expanded in x around 0
Applied rewrites53.6%
Applied rewrites54.2%
Taylor expanded in c around 0
Applied rewrites80.6%
if -9.99999999999999991e131 < (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) #s(literal 16 binary64))) < -5e64Initial program 100.0%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6499.5
Applied rewrites99.5%
Taylor expanded in x around 0
Applied rewrites61.5%
Applied rewrites61.5%
Taylor expanded in z around 0
Applied rewrites99.5%
if -5e64 < (+.f64 (*.f64 x y) (/.f64 (*.f64 z t) #s(literal 16 binary64))) < 4.9999999999999999e119Initial program 100.0%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6491.4
Applied rewrites91.4%
Taylor expanded in x around 0
Applied rewrites83.8%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* x y) -4e-23)
(fma y x (fma (* t z) 0.0625 c))
(if (<= (* x y) 2e+42)
(+ (fma (* t 0.0625) z (* -0.25 (* a b))) c)
(fma (* z 0.0625) t (fma x y c)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((x * y) <= -4e-23) {
tmp = fma(y, x, fma((t * z), 0.0625, c));
} else if ((x * y) <= 2e+42) {
tmp = fma((t * 0.0625), z, (-0.25 * (a * b))) + c;
} else {
tmp = fma((z * 0.0625), t, fma(x, y, c));
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(x * y) <= -4e-23) tmp = fma(y, x, fma(Float64(t * z), 0.0625, c)); elseif (Float64(x * y) <= 2e+42) tmp = Float64(fma(Float64(t * 0.0625), z, Float64(-0.25 * Float64(a * b))) + c); else tmp = fma(Float64(z * 0.0625), t, fma(x, y, c)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(x * y), $MachinePrecision], -4e-23], N[(y * x + N[(N[(t * z), $MachinePrecision] * 0.0625 + c), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2e+42], N[(N[(N[(t * 0.0625), $MachinePrecision] * z + N[(-0.25 * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + c), $MachinePrecision], N[(N[(z * 0.0625), $MachinePrecision] * t + N[(x * y + c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \cdot y \leq -4 \cdot 10^{-23}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\right)\\
\mathbf{elif}\;x \cdot y \leq 2 \cdot 10^{+42}:\\
\;\;\;\;\mathsf{fma}\left(t \cdot 0.0625, z, -0.25 \cdot \left(a \cdot b\right)\right) + c\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot 0.0625, t, \mathsf{fma}\left(x, y, c\right)\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -3.99999999999999984e-23Initial program 93.1%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6491.5
Applied rewrites91.5%
if -3.99999999999999984e-23 < (*.f64 x y) < 2.00000000000000009e42Initial program 100.0%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites100.0%
Taylor expanded in x around 0
lower-*.f64N/A
lower-*.f6498.7
Applied rewrites98.7%
if 2.00000000000000009e42 < (*.f64 x y) Initial program 94.3%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.3
Applied rewrites86.3%
Applied rewrites88.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* z 0.0625) t c)))
(if (<= (* z t) -2e+133)
t_1
(if (<= (* z t) -1e-239)
(fma x y c)
(if (<= (* z t) 1e+117) (fma -0.25 (* a b) c) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = fma((z * 0.0625), t, c);
double tmp;
if ((z * t) <= -2e+133) {
tmp = t_1;
} else if ((z * t) <= -1e-239) {
tmp = fma(x, y, c);
} else if ((z * t) <= 1e+117) {
tmp = fma(-0.25, (a * b), c);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = fma(Float64(z * 0.0625), t, c) tmp = 0.0 if (Float64(z * t) <= -2e+133) tmp = t_1; elseif (Float64(z * t) <= -1e-239) tmp = fma(x, y, c); elseif (Float64(z * t) <= 1e+117) tmp = fma(-0.25, Float64(a * b), c); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(z * 0.0625), $MachinePrecision] * t + c), $MachinePrecision]}, If[LessEqual[N[(z * t), $MachinePrecision], -2e+133], t$95$1, If[LessEqual[N[(z * t), $MachinePrecision], -1e-239], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(z * t), $MachinePrecision], 1e+117], N[(-0.25 * N[(a * b), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z \cdot 0.0625, t, c\right)\\
\mathbf{if}\;z \cdot t \leq -2 \cdot 10^{+133}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \cdot t \leq -1 \cdot 10^{-239}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;z \cdot t \leq 10^{+117}:\\
\;\;\;\;\mathsf{fma}\left(-0.25, a \cdot b, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -2e133 or 1.00000000000000005e117 < (*.f64 z t) Initial program 94.0%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6487.5
Applied rewrites87.5%
Taylor expanded in x around 0
Applied rewrites78.5%
Applied rewrites79.4%
if -2e133 < (*.f64 z t) < -1.0000000000000001e-239Initial program 98.2%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6477.4
Applied rewrites77.4%
Taylor expanded in x around 0
Applied rewrites34.1%
Applied rewrites34.1%
Taylor expanded in z around 0
Applied rewrites74.0%
if -1.0000000000000001e-239 < (*.f64 z t) < 1.00000000000000005e117Initial program 100.0%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6493.3
Applied rewrites93.3%
Taylor expanded in x around 0
Applied rewrites67.3%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* z t) -2e+133)
(* (* z 0.0625) t)
(if (<= (* z t) -1e-239)
(fma x y c)
(if (<= (* z t) 2e+130) (fma -0.25 (* a b) c) (* (* z t) 0.0625)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((z * t) <= -2e+133) {
tmp = (z * 0.0625) * t;
} else if ((z * t) <= -1e-239) {
tmp = fma(x, y, c);
} else if ((z * t) <= 2e+130) {
tmp = fma(-0.25, (a * b), c);
} else {
tmp = (z * t) * 0.0625;
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(z * t) <= -2e+133) tmp = Float64(Float64(z * 0.0625) * t); elseif (Float64(z * t) <= -1e-239) tmp = fma(x, y, c); elseif (Float64(z * t) <= 2e+130) tmp = fma(-0.25, Float64(a * b), c); else tmp = Float64(Float64(z * t) * 0.0625); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(z * t), $MachinePrecision], -2e+133], N[(N[(z * 0.0625), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[N[(z * t), $MachinePrecision], -1e-239], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(z * t), $MachinePrecision], 2e+130], N[(-0.25 * N[(a * b), $MachinePrecision] + c), $MachinePrecision], N[(N[(z * t), $MachinePrecision] * 0.0625), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot t \leq -2 \cdot 10^{+133}:\\
\;\;\;\;\left(z \cdot 0.0625\right) \cdot t\\
\mathbf{elif}\;z \cdot t \leq -1 \cdot 10^{-239}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;z \cdot t \leq 2 \cdot 10^{+130}:\\
\;\;\;\;\mathsf{fma}\left(-0.25, a \cdot b, c\right)\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot t\right) \cdot 0.0625\\
\end{array}
\end{array}
if (*.f64 z t) < -2e133Initial program 93.1%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites98.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6472.0
Applied rewrites72.0%
Applied rewrites73.5%
if -2e133 < (*.f64 z t) < -1.0000000000000001e-239Initial program 98.2%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6477.4
Applied rewrites77.4%
Taylor expanded in x around 0
Applied rewrites34.1%
Applied rewrites34.1%
Taylor expanded in z around 0
Applied rewrites74.0%
if -1.0000000000000001e-239 < (*.f64 z t) < 2.0000000000000001e130Initial program 100.0%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6492.6
Applied rewrites92.6%
Taylor expanded in x around 0
Applied rewrites67.3%
if 2.0000000000000001e130 < (*.f64 z t) Initial program 94.9%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites94.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6472.5
Applied rewrites72.5%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* t z) 0.0625 c)))
(if (<= (* x y) -4e-23)
(fma y x t_1)
(if (<= (* x y) 2e+42)
(fma -0.25 (* b a) t_1)
(fma (* z 0.0625) t (fma x y c))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = fma((t * z), 0.0625, c);
double tmp;
if ((x * y) <= -4e-23) {
tmp = fma(y, x, t_1);
} else if ((x * y) <= 2e+42) {
tmp = fma(-0.25, (b * a), t_1);
} else {
tmp = fma((z * 0.0625), t, fma(x, y, c));
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = fma(Float64(t * z), 0.0625, c) tmp = 0.0 if (Float64(x * y) <= -4e-23) tmp = fma(y, x, t_1); elseif (Float64(x * y) <= 2e+42) tmp = fma(-0.25, Float64(b * a), t_1); else tmp = fma(Float64(z * 0.0625), t, fma(x, y, c)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(N[(t * z), $MachinePrecision] * 0.0625 + c), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -4e-23], N[(y * x + t$95$1), $MachinePrecision], If[LessEqual[N[(x * y), $MachinePrecision], 2e+42], N[(-0.25 * N[(b * a), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(z * 0.0625), $MachinePrecision] * t + N[(x * y + c), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\mathbf{if}\;x \cdot y \leq -4 \cdot 10^{-23}:\\
\;\;\;\;\mathsf{fma}\left(y, x, t\_1\right)\\
\mathbf{elif}\;x \cdot y \leq 2 \cdot 10^{+42}:\\
\;\;\;\;\mathsf{fma}\left(-0.25, b \cdot a, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot 0.0625, t, \mathsf{fma}\left(x, y, c\right)\right)\\
\end{array}
\end{array}
if (*.f64 x y) < -3.99999999999999984e-23Initial program 93.1%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6491.5
Applied rewrites91.5%
if -3.99999999999999984e-23 < (*.f64 x y) < 2.00000000000000009e42Initial program 100.0%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6498.7
Applied rewrites98.7%
if 2.00000000000000009e42 < (*.f64 x y) Initial program 94.3%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6486.3
Applied rewrites86.3%
Applied rewrites88.0%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* a b) -2e+177) (not (<= (* a b) 2e+167))) (fma -0.25 (* b a) (fma y x c)) (fma y x (fma (* t z) 0.0625 c))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (((a * b) <= -2e+177) || !((a * b) <= 2e+167)) {
tmp = fma(-0.25, (b * a), fma(y, x, c));
} else {
tmp = fma(y, x, fma((t * z), 0.0625, c));
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((Float64(a * b) <= -2e+177) || !(Float64(a * b) <= 2e+167)) tmp = fma(-0.25, Float64(b * a), fma(y, x, c)); else tmp = fma(y, x, fma(Float64(t * z), 0.0625, c)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(a * b), $MachinePrecision], -2e+177], N[Not[LessEqual[N[(a * b), $MachinePrecision], 2e+167]], $MachinePrecision]], N[(-0.25 * N[(b * a), $MachinePrecision] + N[(y * x + c), $MachinePrecision]), $MachinePrecision], N[(y * x + N[(N[(t * z), $MachinePrecision] * 0.0625 + c), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \cdot b \leq -2 \cdot 10^{+177} \lor \neg \left(a \cdot b \leq 2 \cdot 10^{+167}\right):\\
\;\;\;\;\mathsf{fma}\left(-0.25, b \cdot a, \mathsf{fma}\left(y, x, c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, x, \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\right)\\
\end{array}
\end{array}
if (*.f64 a b) < -2e177 or 2.0000000000000001e167 < (*.f64 a b) Initial program 95.7%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6491.3
Applied rewrites91.3%
if -2e177 < (*.f64 a b) < 2.0000000000000001e167Initial program 97.9%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6493.0
Applied rewrites93.0%
Final simplification92.6%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* z t) -2e+133)
(fma (* z 0.0625) t c)
(if (<= (* z t) 5e+183)
(fma -0.25 (* b a) (fma y x c))
(fma (* z t) 0.0625 (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((z * t) <= -2e+133) {
tmp = fma((z * 0.0625), t, c);
} else if ((z * t) <= 5e+183) {
tmp = fma(-0.25, (b * a), fma(y, x, c));
} else {
tmp = fma((z * t), 0.0625, (x * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(z * t) <= -2e+133) tmp = fma(Float64(z * 0.0625), t, c); elseif (Float64(z * t) <= 5e+183) tmp = fma(-0.25, Float64(b * a), fma(y, x, c)); else tmp = fma(Float64(z * t), 0.0625, Float64(x * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(z * t), $MachinePrecision], -2e+133], N[(N[(z * 0.0625), $MachinePrecision] * t + c), $MachinePrecision], If[LessEqual[N[(z * t), $MachinePrecision], 5e+183], N[(-0.25 * N[(b * a), $MachinePrecision] + N[(y * x + c), $MachinePrecision]), $MachinePrecision], N[(N[(z * t), $MachinePrecision] * 0.0625 + N[(x * y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot t \leq -2 \cdot 10^{+133}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot 0.0625, t, c\right)\\
\mathbf{elif}\;z \cdot t \leq 5 \cdot 10^{+183}:\\
\;\;\;\;\mathsf{fma}\left(-0.25, b \cdot a, \mathsf{fma}\left(y, x, c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot t, 0.0625, x \cdot y\right)\\
\end{array}
\end{array}
if (*.f64 z t) < -2e133Initial program 93.1%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6483.3
Applied rewrites83.3%
Taylor expanded in x around 0
Applied rewrites78.2%
Applied rewrites79.7%
if -2e133 < (*.f64 z t) < 5.00000000000000009e183Initial program 99.4%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6492.4
Applied rewrites92.4%
if 5.00000000000000009e183 < (*.f64 z t) Initial program 93.9%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6494.2
Applied rewrites94.2%
Taylor expanded in x around 0
Applied rewrites82.2%
Applied rewrites82.2%
Taylor expanded in c around 0
Applied rewrites85.0%
(FPCore (x y z t a b c) :precision binary64 (if (or (<= (* z t) -2e+133) (not (<= (* z t) 2e+177))) (* (* z 0.0625) t) (fma x y c)))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if (((z * t) <= -2e+133) || !((z * t) <= 2e+177)) {
tmp = (z * 0.0625) * t;
} else {
tmp = fma(x, y, c);
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if ((Float64(z * t) <= -2e+133) || !(Float64(z * t) <= 2e+177)) tmp = Float64(Float64(z * 0.0625) * t); else tmp = fma(x, y, c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[Or[LessEqual[N[(z * t), $MachinePrecision], -2e+133], N[Not[LessEqual[N[(z * t), $MachinePrecision], 2e+177]], $MachinePrecision]], N[(N[(z * 0.0625), $MachinePrecision] * t), $MachinePrecision], N[(x * y + c), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot t \leq -2 \cdot 10^{+133} \lor \neg \left(z \cdot t \leq 2 \cdot 10^{+177}\right):\\
\;\;\;\;\left(z \cdot 0.0625\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\end{array}
\end{array}
if (*.f64 z t) < -2e133 or 2e177 < (*.f64 z t) Initial program 93.5%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites96.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6473.9
Applied rewrites73.9%
Applied rewrites74.8%
if -2e133 < (*.f64 z t) < 2e177Initial program 99.4%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.9
Applied rewrites69.9%
Taylor expanded in x around 0
Applied rewrites37.5%
Applied rewrites37.5%
Taylor expanded in z around 0
Applied rewrites63.1%
Final simplification67.2%
(FPCore (x y z t a b c) :precision binary64 (if (<= (* z t) -2e+133) (* (* z 0.0625) t) (if (<= (* z t) 2e+177) (fma x y c) (* (* z t) 0.0625))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double tmp;
if ((z * t) <= -2e+133) {
tmp = (z * 0.0625) * t;
} else if ((z * t) <= 2e+177) {
tmp = fma(x, y, c);
} else {
tmp = (z * t) * 0.0625;
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(z * t) <= -2e+133) tmp = Float64(Float64(z * 0.0625) * t); elseif (Float64(z * t) <= 2e+177) tmp = fma(x, y, c); else tmp = Float64(Float64(z * t) * 0.0625); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(z * t), $MachinePrecision], -2e+133], N[(N[(z * 0.0625), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[N[(z * t), $MachinePrecision], 2e+177], N[(x * y + c), $MachinePrecision], N[(N[(z * t), $MachinePrecision] * 0.0625), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \cdot t \leq -2 \cdot 10^{+133}:\\
\;\;\;\;\left(z \cdot 0.0625\right) \cdot t\\
\mathbf{elif}\;z \cdot t \leq 2 \cdot 10^{+177}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot t\right) \cdot 0.0625\\
\end{array}
\end{array}
if (*.f64 z t) < -2e133Initial program 93.1%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites98.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6472.0
Applied rewrites72.0%
Applied rewrites73.5%
if -2e133 < (*.f64 z t) < 2e177Initial program 99.4%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6469.9
Applied rewrites69.9%
Taylor expanded in x around 0
Applied rewrites37.5%
Applied rewrites37.5%
Taylor expanded in z around 0
Applied rewrites63.1%
if 2e177 < (*.f64 z t) Initial program 94.1%
lift--.f64N/A
sub-negN/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
div-invN/A
lower-*.f64N/A
metadata-evalN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lift-/.f64N/A
div-invN/A
distribute-rgt-neg-inN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower-*.f64N/A
Applied rewrites94.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6477.0
Applied rewrites77.0%
(FPCore (x y z t a b c) :precision binary64 (fma x y c))
double code(double x, double y, double z, double t, double a, double b, double c) {
return fma(x, y, c);
}
function code(x, y, z, t, a, b, c) return fma(x, y, c) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(x * y + c), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y, c\right)
\end{array}
Initial program 97.3%
Taylor expanded in a around 0
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6475.7
Applied rewrites75.7%
Taylor expanded in x around 0
Applied rewrites52.0%
Applied rewrites52.4%
Taylor expanded in z around 0
Applied rewrites46.0%
(FPCore (x y z t a b c) :precision binary64 (* y x))
double code(double x, double y, double z, double t, double a, double b, double c) {
return y * x;
}
real(8) function code(x, y, z, t, a, b, c)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = y * x
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return y * x;
}
def code(x, y, z, t, a, b, c): return y * x
function code(x, y, z, t, a, b, c) return Float64(y * x) end
function tmp = code(x, y, z, t, a, b, c) tmp = y * x; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(y * x), $MachinePrecision]
\begin{array}{l}
\\
y \cdot x
\end{array}
Initial program 97.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f6426.0
Applied rewrites26.0%
herbie shell --seed 2024299
(FPCore (x y z t a b c)
:name "Diagrams.Solve.Polynomial:quartForm from diagrams-solve-0.1, C"
:precision binary64
(+ (- (+ (* x y) (/ (* z t) 16.0)) (/ (* a b) 4.0)) c))