
(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 a (* b -0.25) (fma 0.0625 (* t z) (fma x y c))))
double code(double x, double y, double z, double t, double a, double b, double c) {
return fma(a, (b * -0.25), fma(0.0625, (t * z), fma(x, y, c)));
}
function code(x, y, z, t, a, b, c) return fma(a, Float64(b * -0.25), fma(0.0625, Float64(t * z), fma(x, y, c))) end
code[x_, y_, z_, t_, a_, b_, c_] := N[(a * N[(b * -0.25), $MachinePrecision] + N[(0.0625 * N[(t * z), $MachinePrecision] + N[(x * y + c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(a, b \cdot -0.25, \mathsf{fma}\left(0.0625, t \cdot z, \mathsf{fma}\left(x, y, c\right)\right)\right)
\end{array}
Initial program 97.6%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6498.8
Applied rewrites98.8%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* t z) 0.0625 c)))
(if (<= (* t z) -5e+164)
t_1
(if (<= (* t z) -0.004)
(fma y x (* a (* b -0.25)))
(if (<= (* t z) 5e-189)
(fma x y c)
(if (<= (* t z) 1e+68) (fma a (* b -0.25) c) t_1))))))
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 ((t * z) <= -5e+164) {
tmp = t_1;
} else if ((t * z) <= -0.004) {
tmp = fma(y, x, (a * (b * -0.25)));
} else if ((t * z) <= 5e-189) {
tmp = fma(x, y, c);
} else if ((t * z) <= 1e+68) {
tmp = fma(a, (b * -0.25), c);
} else {
tmp = t_1;
}
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(t * z) <= -5e+164) tmp = t_1; elseif (Float64(t * z) <= -0.004) tmp = fma(y, x, Float64(a * Float64(b * -0.25))); elseif (Float64(t * z) <= 5e-189) tmp = fma(x, y, c); elseif (Float64(t * z) <= 1e+68) tmp = fma(a, Float64(b * -0.25), c); else tmp = t_1; 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[(t * z), $MachinePrecision], -5e+164], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], -0.004], N[(y * x + N[(a * N[(b * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 5e-189], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+68], N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+164}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq -0.004:\\
\;\;\;\;\mathsf{fma}\left(y, x, a \cdot \left(b \cdot -0.25\right)\right)\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{-189}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t \cdot z \leq 10^{+68}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -4.9999999999999995e164 or 9.99999999999999953e67 < (*.f64 z t) Initial program 96.7%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.5
Applied rewrites81.5%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.5
Applied rewrites81.5%
if -4.9999999999999995e164 < (*.f64 z t) < -0.0040000000000000001Initial program 97.3%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6497.3
Applied rewrites97.3%
Taylor expanded in x around inf
lower-*.f6466.4
Applied rewrites66.4%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6469.1
Applied rewrites69.1%
if -0.0040000000000000001 < (*.f64 z t) < 4.9999999999999997e-189Initial program 97.5%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.4
Applied rewrites95.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
if 4.9999999999999997e-189 < (*.f64 z t) < 9.99999999999999953e67Initial program 99.9%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.3
Applied rewrites95.3%
lift-*.f64N/A
lift-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f6495.3
Applied rewrites95.3%
Taylor expanded in y around 0
associate-*r*N/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6485.1
Applied rewrites85.1%
Final simplification78.4%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* t z) 0.0625 c)))
(if (<= (* t z) -5e+164)
t_1
(if (<= (* t z) -0.004)
(fma a (* b -0.25) (* x y))
(if (<= (* t z) 5e-189)
(fma x y c)
(if (<= (* t z) 1e+68) (fma a (* b -0.25) c) t_1))))))
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 ((t * z) <= -5e+164) {
tmp = t_1;
} else if ((t * z) <= -0.004) {
tmp = fma(a, (b * -0.25), (x * y));
} else if ((t * z) <= 5e-189) {
tmp = fma(x, y, c);
} else if ((t * z) <= 1e+68) {
tmp = fma(a, (b * -0.25), c);
} else {
tmp = t_1;
}
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(t * z) <= -5e+164) tmp = t_1; elseif (Float64(t * z) <= -0.004) tmp = fma(a, Float64(b * -0.25), Float64(x * y)); elseif (Float64(t * z) <= 5e-189) tmp = fma(x, y, c); elseif (Float64(t * z) <= 1e+68) tmp = fma(a, Float64(b * -0.25), c); else tmp = t_1; 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[(t * z), $MachinePrecision], -5e+164], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], -0.004], N[(a * N[(b * -0.25), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 5e-189], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+68], N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+164}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq -0.004:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, x \cdot y\right)\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{-189}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t \cdot z \leq 10^{+68}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -4.9999999999999995e164 or 9.99999999999999953e67 < (*.f64 z t) Initial program 96.7%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.5
Applied rewrites81.5%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.5
Applied rewrites81.5%
if -4.9999999999999995e164 < (*.f64 z t) < -0.0040000000000000001Initial program 97.3%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6497.3
Applied rewrites97.3%
Taylor expanded in x around inf
lower-*.f6466.4
Applied rewrites66.4%
if -0.0040000000000000001 < (*.f64 z t) < 4.9999999999999997e-189Initial program 97.5%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.4
Applied rewrites95.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
if 4.9999999999999997e-189 < (*.f64 z t) < 9.99999999999999953e67Initial program 99.9%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.3
Applied rewrites95.3%
lift-*.f64N/A
lift-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f6495.3
Applied rewrites95.3%
Taylor expanded in y around 0
associate-*r*N/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6485.1
Applied rewrites85.1%
Final simplification78.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* t z) 0.0625 c)))
(if (<= (* t z) -5e+164)
t_1
(if (<= (* t z) -0.004)
(fma -0.25 (* a b) (* x y))
(if (<= (* t z) 5e-189)
(fma x y c)
(if (<= (* t z) 1e+68) (fma a (* b -0.25) c) t_1))))))
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 ((t * z) <= -5e+164) {
tmp = t_1;
} else if ((t * z) <= -0.004) {
tmp = fma(-0.25, (a * b), (x * y));
} else if ((t * z) <= 5e-189) {
tmp = fma(x, y, c);
} else if ((t * z) <= 1e+68) {
tmp = fma(a, (b * -0.25), c);
} else {
tmp = t_1;
}
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(t * z) <= -5e+164) tmp = t_1; elseif (Float64(t * z) <= -0.004) tmp = fma(-0.25, Float64(a * b), Float64(x * y)); elseif (Float64(t * z) <= 5e-189) tmp = fma(x, y, c); elseif (Float64(t * z) <= 1e+68) tmp = fma(a, Float64(b * -0.25), c); else tmp = t_1; 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[(t * z), $MachinePrecision], -5e+164], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], -0.004], N[(-0.25 * N[(a * b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 5e-189], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+68], N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+164}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq -0.004:\\
\;\;\;\;\mathsf{fma}\left(-0.25, a \cdot b, x \cdot y\right)\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{-189}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t \cdot z \leq 10^{+68}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -4.9999999999999995e164 or 9.99999999999999953e67 < (*.f64 z t) Initial program 96.7%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.5
Applied rewrites81.5%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.5
Applied rewrites81.5%
if -4.9999999999999995e164 < (*.f64 z t) < -0.0040000000000000001Initial program 97.3%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6484.3
Applied rewrites84.3%
Taylor expanded in c around 0
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f6466.4
Applied rewrites66.4%
if -0.0040000000000000001 < (*.f64 z t) < 4.9999999999999997e-189Initial program 97.5%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.4
Applied rewrites95.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
if 4.9999999999999997e-189 < (*.f64 z t) < 9.99999999999999953e67Initial program 99.9%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.3
Applied rewrites95.3%
lift-*.f64N/A
lift-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f6495.3
Applied rewrites95.3%
Taylor expanded in y around 0
associate-*r*N/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6485.1
Applied rewrites85.1%
Final simplification78.0%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma (* t z) 0.0625 c)))
(if (<= (* t z) -5e+185)
t_1
(if (<= (* t z) -0.004)
(fma -0.25 (* a b) c)
(if (<= (* t z) 5e-189)
(fma x y c)
(if (<= (* t z) 1e+68) (fma a (* b -0.25) c) t_1))))))
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 ((t * z) <= -5e+185) {
tmp = t_1;
} else if ((t * z) <= -0.004) {
tmp = fma(-0.25, (a * b), c);
} else if ((t * z) <= 5e-189) {
tmp = fma(x, y, c);
} else if ((t * z) <= 1e+68) {
tmp = fma(a, (b * -0.25), c);
} else {
tmp = t_1;
}
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(t * z) <= -5e+185) tmp = t_1; elseif (Float64(t * z) <= -0.004) tmp = fma(-0.25, Float64(a * b), c); elseif (Float64(t * z) <= 5e-189) tmp = fma(x, y, c); elseif (Float64(t * z) <= 1e+68) tmp = fma(a, Float64(b * -0.25), c); else tmp = t_1; 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[(t * z), $MachinePrecision], -5e+185], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], -0.004], N[(-0.25 * N[(a * b), $MachinePrecision] + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 5e-189], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+68], N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+185}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq -0.004:\\
\;\;\;\;\mathsf{fma}\left(-0.25, a \cdot b, c\right)\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{-189}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t \cdot z \leq 10^{+68}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -4.9999999999999999e185 or 9.99999999999999953e67 < (*.f64 z t) Initial program 96.7%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.3
Applied rewrites81.3%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.3
Applied rewrites81.3%
if -4.9999999999999999e185 < (*.f64 z t) < -0.0040000000000000001Initial program 97.3%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6484.7
Applied rewrites84.7%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
lower-*.f6463.6
Applied rewrites63.6%
if -0.0040000000000000001 < (*.f64 z t) < 4.9999999999999997e-189Initial program 97.5%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.4
Applied rewrites95.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
if 4.9999999999999997e-189 < (*.f64 z t) < 9.99999999999999953e67Initial program 99.9%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.3
Applied rewrites95.3%
lift-*.f64N/A
lift-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-fma.f6495.3
Applied rewrites95.3%
Taylor expanded in y around 0
associate-*r*N/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6485.1
Applied rewrites85.1%
Final simplification77.5%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma -0.25 (* a b) c)) (t_2 (* 0.0625 (* t z))))
(if (<= (* t z) -5e+185)
t_2
(if (<= (* t z) -0.004)
t_1
(if (<= (* t z) 5e-189)
(fma x y c)
(if (<= (* t z) 1e+124) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = fma(-0.25, (a * b), c);
double t_2 = 0.0625 * (t * z);
double tmp;
if ((t * z) <= -5e+185) {
tmp = t_2;
} else if ((t * z) <= -0.004) {
tmp = t_1;
} else if ((t * z) <= 5e-189) {
tmp = fma(x, y, c);
} else if ((t * z) <= 1e+124) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = fma(-0.25, Float64(a * b), c) t_2 = Float64(0.0625 * Float64(t * z)) tmp = 0.0 if (Float64(t * z) <= -5e+185) tmp = t_2; elseif (Float64(t * z) <= -0.004) tmp = t_1; elseif (Float64(t * z) <= 5e-189) tmp = fma(x, y, c); elseif (Float64(t * z) <= 1e+124) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(-0.25 * N[(a * b), $MachinePrecision] + c), $MachinePrecision]}, Block[{t$95$2 = N[(0.0625 * N[(t * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t * z), $MachinePrecision], -5e+185], t$95$2, If[LessEqual[N[(t * z), $MachinePrecision], -0.004], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], 5e-189], N[(x * y + c), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 1e+124], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-0.25, a \cdot b, c\right)\\
t_2 := 0.0625 \cdot \left(t \cdot z\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+185}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \cdot z \leq -0.004:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{-189}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{elif}\;t \cdot z \leq 10^{+124}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 z t) < -4.9999999999999999e185 or 9.99999999999999948e123 < (*.f64 z t) Initial program 96.1%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6478.2
Applied rewrites78.2%
if -4.9999999999999999e185 < (*.f64 z t) < -0.0040000000000000001 or 4.9999999999999997e-189 < (*.f64 z t) < 9.99999999999999948e123Initial program 98.9%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6487.8
Applied rewrites87.8%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
lower-*.f6471.6
Applied rewrites71.6%
if -0.0040000000000000001 < (*.f64 z t) < 4.9999999999999997e-189Initial program 97.5%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6495.4
Applied rewrites95.4%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
Final simplification74.7%
(FPCore (x y z t a b c)
:precision binary64
(let* ((t_1 (fma a (* b -0.25) (fma x y c))))
(if (<= (* x y) -5e+193)
t_1
(if (<= (* x y) 2e+35) (fma 0.0625 (* t z) (fma a (* b -0.25) c)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = fma(a, (b * -0.25), fma(x, y, c));
double tmp;
if ((x * y) <= -5e+193) {
tmp = t_1;
} else if ((x * y) <= 2e+35) {
tmp = fma(0.0625, (t * z), fma(a, (b * -0.25), c));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = fma(a, Float64(b * -0.25), fma(x, y, c)) tmp = 0.0 if (Float64(x * y) <= -5e+193) tmp = t_1; elseif (Float64(x * y) <= 2e+35) tmp = fma(0.0625, Float64(t * z), fma(a, Float64(b * -0.25), c)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(a * N[(b * -0.25), $MachinePrecision] + N[(x * y + c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(x * y), $MachinePrecision], -5e+193], t$95$1, If[LessEqual[N[(x * y), $MachinePrecision], 2e+35], N[(0.0625 * N[(t * z), $MachinePrecision] + N[(a * N[(b * -0.25), $MachinePrecision] + c), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(a, b \cdot -0.25, \mathsf{fma}\left(x, y, c\right)\right)\\
\mathbf{if}\;x \cdot y \leq -5 \cdot 10^{+193}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \cdot y \leq 2 \cdot 10^{+35}:\\
\;\;\;\;\mathsf{fma}\left(0.0625, t \cdot z, \mathsf{fma}\left(a, b \cdot -0.25, c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 x y) < -4.99999999999999972e193 or 1.9999999999999999e35 < (*.f64 x y) Initial program 92.6%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6486.9
Applied rewrites86.9%
if -4.99999999999999972e193 < (*.f64 x y) < 1.9999999999999999e35Initial program 100.0%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
+-commutativeN/A
metadata-evalN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6496.2
Applied rewrites96.2%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* t z) -5e+205)
(fma a (* b -0.25) (* 0.0625 (* t z)))
(if (<= (* t z) 4e+95)
(fma a (* b -0.25) (fma x y c))
(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 ((t * z) <= -5e+205) {
tmp = fma(a, (b * -0.25), (0.0625 * (t * z)));
} else if ((t * z) <= 4e+95) {
tmp = fma(a, (b * -0.25), fma(x, y, c));
} else {
tmp = fma((t * z), 0.0625, c);
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(t * z) <= -5e+205) tmp = fma(a, Float64(b * -0.25), Float64(0.0625 * Float64(t * z))); elseif (Float64(t * z) <= 4e+95) tmp = fma(a, Float64(b * -0.25), fma(x, y, c)); else tmp = fma(Float64(t * z), 0.0625, c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(t * z), $MachinePrecision], -5e+205], N[(a * N[(b * -0.25), $MachinePrecision] + N[(0.0625 * N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 4e+95], N[(a * N[(b * -0.25), $MachinePrecision] + N[(x * y + c), $MachinePrecision]), $MachinePrecision], N[(N[(t * z), $MachinePrecision] * 0.0625 + c), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+205}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, 0.0625 \cdot \left(t \cdot z\right)\right)\\
\mathbf{elif}\;t \cdot z \leq 4 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, \mathsf{fma}\left(x, y, c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\end{array}
\end{array}
if (*.f64 z t) < -5.0000000000000002e205Initial program 100.0%
Taylor expanded in x around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
associate-+r+N/A
+-commutativeN/A
associate-+l+N/A
lower-fma.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f64100.0
Applied rewrites100.0%
Taylor expanded in t around inf
lower-*.f64N/A
lower-*.f6496.2
Applied rewrites96.2%
if -5.0000000000000002e205 < (*.f64 z t) < 4.00000000000000008e95Initial program 98.3%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6491.2
Applied rewrites91.2%
if 4.00000000000000008e95 < (*.f64 z t) Initial program 94.4%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.8
Applied rewrites81.8%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.8
Applied rewrites81.8%
Final simplification89.7%
(FPCore (x y z t a b c)
:precision binary64
(if (<= (* t z) -5e+205)
(* 0.0625 (* t z))
(if (<= (* t z) 4e+95)
(fma a (* b -0.25) (fma x y c))
(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 ((t * z) <= -5e+205) {
tmp = 0.0625 * (t * z);
} else if ((t * z) <= 4e+95) {
tmp = fma(a, (b * -0.25), fma(x, y, c));
} else {
tmp = fma((t * z), 0.0625, c);
}
return tmp;
}
function code(x, y, z, t, a, b, c) tmp = 0.0 if (Float64(t * z) <= -5e+205) tmp = Float64(0.0625 * Float64(t * z)); elseif (Float64(t * z) <= 4e+95) tmp = fma(a, Float64(b * -0.25), fma(x, y, c)); else tmp = fma(Float64(t * z), 0.0625, c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := If[LessEqual[N[(t * z), $MachinePrecision], -5e+205], N[(0.0625 * N[(t * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(t * z), $MachinePrecision], 4e+95], N[(a * N[(b * -0.25), $MachinePrecision] + N[(x * y + c), $MachinePrecision]), $MachinePrecision], N[(N[(t * z), $MachinePrecision] * 0.0625 + c), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+205}:\\
\;\;\;\;0.0625 \cdot \left(t \cdot z\right)\\
\mathbf{elif}\;t \cdot z \leq 4 \cdot 10^{+95}:\\
\;\;\;\;\mathsf{fma}\left(a, b \cdot -0.25, \mathsf{fma}\left(x, y, c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t \cdot z, 0.0625, c\right)\\
\end{array}
\end{array}
if (*.f64 z t) < -5.0000000000000002e205Initial program 100.0%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6492.2
Applied rewrites92.2%
if -5.0000000000000002e205 < (*.f64 z t) < 4.00000000000000008e95Initial program 98.3%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6491.2
Applied rewrites91.2%
if 4.00000000000000008e95 < (*.f64 z t) Initial program 94.4%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6481.8
Applied rewrites81.8%
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6481.8
Applied rewrites81.8%
Final simplification89.3%
(FPCore (x y z t a b c) :precision binary64 (let* ((t_1 (* 0.0625 (* t z)))) (if (<= (* t z) -5e+205) t_1 (if (<= (* t z) 5e+220) (fma x y c) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c) {
double t_1 = 0.0625 * (t * z);
double tmp;
if ((t * z) <= -5e+205) {
tmp = t_1;
} else if ((t * z) <= 5e+220) {
tmp = fma(x, y, c);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c) t_1 = Float64(0.0625 * Float64(t * z)) tmp = 0.0 if (Float64(t * z) <= -5e+205) tmp = t_1; elseif (Float64(t * z) <= 5e+220) tmp = fma(x, y, c); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_] := Block[{t$95$1 = N[(0.0625 * N[(t * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t * z), $MachinePrecision], -5e+205], t$95$1, If[LessEqual[N[(t * z), $MachinePrecision], 5e+220], N[(x * y + c), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.0625 \cdot \left(t \cdot z\right)\\
\mathbf{if}\;t \cdot z \leq -5 \cdot 10^{+205}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \cdot z \leq 5 \cdot 10^{+220}:\\
\;\;\;\;\mathsf{fma}\left(x, y, c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (*.f64 z t) < -5.0000000000000002e205 or 5.0000000000000002e220 < (*.f64 z t) Initial program 96.3%
Taylor expanded in z around inf
lower-*.f64N/A
lower-*.f6492.1
Applied rewrites92.1%
if -5.0000000000000002e205 < (*.f64 z t) < 5.0000000000000002e220Initial program 98.0%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6487.0
Applied rewrites87.0%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6462.0
Applied rewrites62.0%
Final simplification68.3%
(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.6%
Taylor expanded in z around 0
cancel-sign-sub-invN/A
metadata-evalN/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-fma.f6472.2
Applied rewrites72.2%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f6450.6
Applied rewrites50.6%
(FPCore (x y z t a b c) :precision binary64 (* x y))
double code(double x, double y, double z, double t, double a, double b, double c) {
return x * y;
}
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
end function
public static double code(double x, double y, double z, double t, double a, double b, double c) {
return x * y;
}
def code(x, y, z, t, a, b, c): return x * y
function code(x, y, z, t, a, b, c) return Float64(x * y) end
function tmp = code(x, y, z, t, a, b, c) tmp = x * y; end
code[x_, y_, z_, t_, a_, b_, c_] := N[(x * y), $MachinePrecision]
\begin{array}{l}
\\
x \cdot y
\end{array}
Initial program 97.6%
Taylor expanded in x around inf
lower-*.f6426.2
Applied rewrites26.2%
herbie shell --seed 2024219
(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))