
(FPCore (x y z t a b) :precision binary64 (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))
double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
real(8) function code(x, y, z, t, a, b)
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
code = (x + ((y * z) / t)) / ((a + 1.0d0) + ((y * b) / t))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
def code(x, y, z, t, a, b): return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t))
function code(x, y, z, t, a, b) return Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) end
function tmp = code(x, y, z, t, a, b) tmp = (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 18 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))
double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
real(8) function code(x, y, z, t, a, b)
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
code = (x + ((y * z) / t)) / ((a + 1.0d0) + ((y * b) / t))
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
}
def code(x, y, z, t, a, b): return (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t))
function code(x, y, z, t, a, b) return Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) end
function tmp = code(x, y, z, t, a, b) tmp = (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t)); end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}}
\end{array}
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (/ (* y z) t)))
(t_2 (/ t_1 (+ (+ a 1.0) (/ (* y b) t))))
(t_3
(fma
y
(/ z (fma t (/ (fma a t (* y b)) t) t))
(/ x (+ 1.0 (fma y (/ b t) a))))))
(if (<= t_2 (- INFINITY))
t_3
(if (<= t_2 2e+14)
(/ t_1 (fma b (/ y t) (+ a 1.0)))
(if (<= t_2 INFINITY) t_3 (/ z b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + ((y * z) / t);
double t_2 = t_1 / ((a + 1.0) + ((y * b) / t));
double t_3 = fma(y, (z / fma(t, (fma(a, t, (y * b)) / t), t)), (x / (1.0 + fma(y, (b / t), a))));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_3;
} else if (t_2 <= 2e+14) {
tmp = t_1 / fma(b, (y / t), (a + 1.0));
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_3;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(Float64(y * z) / t)) t_2 = Float64(t_1 / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) t_3 = fma(y, Float64(z / fma(t, Float64(fma(a, t, Float64(y * b)) / t), t)), Float64(x / Float64(1.0 + fma(y, Float64(b / t), a)))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_3; elseif (t_2 <= 2e+14) tmp = Float64(t_1 / fma(b, Float64(y / t), Float64(a + 1.0))); elseif (t_2 <= Inf) tmp = t_3; else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(z / N[(t * N[(N[(a * t + N[(y * b), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] + t), $MachinePrecision]), $MachinePrecision] + N[(x / N[(1.0 + N[(y * N[(b / t), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$3, If[LessEqual[t$95$2, 2e+14], N[(t$95$1 / N[(b * N[(y / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$3, N[(z / b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y \cdot z}{t}\\
t_2 := \frac{t\_1}{\left(a + 1\right) + \frac{y \cdot b}{t}}\\
t_3 := \mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(t, \frac{\mathsf{fma}\left(a, t, y \cdot b\right)}{t}, t\right)}, \frac{x}{1 + \mathsf{fma}\left(y, \frac{b}{t}, a\right)}\right)\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+14}:\\
\;\;\;\;\frac{t\_1}{\mathsf{fma}\left(b, \frac{y}{t}, a + 1\right)}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -inf.0 or 2e14 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 68.9%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites94.2%
Taylor expanded in t around 0
lower-/.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6497.0
Applied rewrites97.0%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2e14Initial program 88.0%
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6491.4
Applied rewrites91.4%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 0.0%
Taylor expanded in y around inf
lower-/.f64100.0
Applied rewrites100.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma y (/ b t) a))
(t_2 (+ x (/ (* y z) t)))
(t_3 (/ t_2 (+ (+ a 1.0) (/ (* y b) t))))
(t_4 (fma y (/ z (fma t t_1 t)) (/ x (+ 1.0 t_1)))))
(if (<= t_3 (- INFINITY))
t_4
(if (<= t_3 2e+14)
(/ t_2 (fma b (/ y t) (+ a 1.0)))
(if (<= t_3 INFINITY) t_4 (/ z b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(y, (b / t), a);
double t_2 = x + ((y * z) / t);
double t_3 = t_2 / ((a + 1.0) + ((y * b) / t));
double t_4 = fma(y, (z / fma(t, t_1, t)), (x / (1.0 + t_1)));
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = t_4;
} else if (t_3 <= 2e+14) {
tmp = t_2 / fma(b, (y / t), (a + 1.0));
} else if (t_3 <= ((double) INFINITY)) {
tmp = t_4;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(y, Float64(b / t), a) t_2 = Float64(x + Float64(Float64(y * z) / t)) t_3 = Float64(t_2 / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) t_4 = fma(y, Float64(z / fma(t, t_1, t)), Float64(x / Float64(1.0 + t_1))) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = t_4; elseif (t_3 <= 2e+14) tmp = Float64(t_2 / fma(b, Float64(y / t), Float64(a + 1.0))); elseif (t_3 <= Inf) tmp = t_4; else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(b / t), $MachinePrecision] + a), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(y * N[(z / N[(t * t$95$1 + t), $MachinePrecision]), $MachinePrecision] + N[(x / N[(1.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], t$95$4, If[LessEqual[t$95$3, 2e+14], N[(t$95$2 / N[(b * N[(y / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], t$95$4, N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y, \frac{b}{t}, a\right)\\
t_2 := x + \frac{y \cdot z}{t}\\
t_3 := \frac{t\_2}{\left(a + 1\right) + \frac{y \cdot b}{t}}\\
t_4 := \mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(t, t\_1, t\right)}, \frac{x}{1 + t\_1}\right)\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 \leq 2 \cdot 10^{+14}:\\
\;\;\;\;\frac{t\_2}{\mathsf{fma}\left(b, \frac{y}{t}, a + 1\right)}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;t\_4\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -inf.0 or 2e14 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 68.9%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites94.2%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2e14Initial program 88.0%
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6491.4
Applied rewrites91.4%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 0.0%
Taylor expanded in y around inf
lower-/.f64100.0
Applied rewrites100.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ x (/ (* y z) t)))
(t_2 (/ t_1 (+ (+ a 1.0) (/ (* y b) t))))
(t_3 (fma y (/ z (fma (+ a 1.0) t (* y b))) (/ x a))))
(if (<= t_2 (- INFINITY))
t_3
(if (<= t_2 5e+294)
(/ t_1 (fma b (/ y t) (+ a 1.0)))
(if (<= t_2 INFINITY) t_3 (/ z b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x + ((y * z) / t);
double t_2 = t_1 / ((a + 1.0) + ((y * b) / t));
double t_3 = fma(y, (z / fma((a + 1.0), t, (y * b))), (x / a));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = t_3;
} else if (t_2 <= 5e+294) {
tmp = t_1 / fma(b, (y / t), (a + 1.0));
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_3;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x + Float64(Float64(y * z) / t)) t_2 = Float64(t_1 / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) t_3 = fma(y, Float64(z / fma(Float64(a + 1.0), t, Float64(y * b))), Float64(x / a)) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = t_3; elseif (t_2 <= 5e+294) tmp = Float64(t_1 / fma(b, Float64(y / t), Float64(a + 1.0))); elseif (t_2 <= Inf) tmp = t_3; else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(z / N[(N[(a + 1.0), $MachinePrecision] * t + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], t$95$3, If[LessEqual[t$95$2, 5e+294], N[(t$95$1 / N[(b * N[(y / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$3, N[(z / b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x + \frac{y \cdot z}{t}\\
t_2 := \frac{t\_1}{\left(a + 1\right) + \frac{y \cdot b}{t}}\\
t_3 := \mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(a + 1, t, y \cdot b\right)}, \frac{x}{a}\right)\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{+294}:\\
\;\;\;\;\frac{t\_1}{\mathsf{fma}\left(b, \frac{y}{t}, a + 1\right)}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -inf.0 or 4.9999999999999999e294 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 36.2%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites88.2%
Taylor expanded in a around inf
lower-/.f6476.9
Applied rewrites76.9%
Taylor expanded in t around 0
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6479.8
Applied rewrites79.8%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
distribute-lft1-inN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6479.9
Applied rewrites79.9%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 4.9999999999999999e294Initial program 90.1%
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6492.5
Applied rewrites92.5%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 0.0%
Taylor expanded in y around inf
lower-/.f64100.0
Applied rewrites100.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t)))))
(if (<= t_1 (- INFINITY))
(fma y (/ z (fma (+ a 1.0) t (* y b))) (/ x a))
(if (<= t_1 INFINITY)
(/ (fma z (/ y t) x) (+ 1.0 (fma b (/ y t) a)))
(/ z b)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = fma(y, (z / fma((a + 1.0), t, (y * b))), (x / a));
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma(z, (y / t), x) / (1.0 + fma(b, (y / t), a));
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = fma(y, Float64(z / fma(Float64(a + 1.0), t, Float64(y * b))), Float64(x / a)); elseif (t_1 <= Inf) tmp = Float64(fma(z, Float64(y / t), x) / Float64(1.0 + fma(b, Float64(y / t), a))); else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(y * N[(z / N[(N[(a + 1.0), $MachinePrecision] * t + N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(1.0 + N[(b * N[(y / t), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z / b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(a + 1, t, y \cdot b\right)}, \frac{x}{a}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{1 + \mathsf{fma}\left(b, \frac{y}{t}, a\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -inf.0Initial program 42.4%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites88.7%
Taylor expanded in a around inf
lower-/.f6472.7
Applied rewrites72.7%
Taylor expanded in t around 0
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6472.7
Applied rewrites72.7%
lift-fma.f64N/A
+-commutativeN/A
lift-fma.f64N/A
distribute-lft1-inN/A
lift-+.f64N/A
lower-fma.f64N/A
lower-*.f6472.8
Applied rewrites72.8%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 85.6%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6482.6
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
Applied rewrites85.6%
lift-/.f64N/A
lift-fma.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-fma.f64N/A
/-rgt-identityN/A
un-div-invN/A
/-rgt-identityN/A
lower-/.f6485.7
lift-fma.f64N/A
lift-/.f64N/A
associate-*r/N/A
associate-*l/N/A
lift-/.f64N/A
*-commutativeN/A
lift-fma.f6486.1
lift-fma.f64N/A
lift-+.f64N/A
associate-+r+N/A
lift-fma.f64N/A
lower-+.f6486.1
Applied rewrites88.2%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 0.0%
Taylor expanded in y around inf
lower-/.f64100.0
Applied rewrites100.0%
Final simplification88.2%
(FPCore (x y z t a b) :precision binary64 (if (<= (/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))) INFINITY) (/ (fma y (/ z t) x) (fma y (/ b t) (+ a 1.0))) (/ z b)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (((x + ((y * z) / t)) / ((a + 1.0) + ((y * b) / t))) <= ((double) INFINITY)) {
tmp = fma(y, (z / t), x) / fma(y, (b / t), (a + 1.0));
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (Float64(Float64(x + Float64(Float64(y * z) / t)) / Float64(Float64(a + 1.0) + Float64(Float64(y * b) / t))) <= Inf) tmp = Float64(fma(y, Float64(z / t), x) / fma(y, Float64(b / t), Float64(a + 1.0))); else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[(N[(x + N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y * b), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision] / N[(y * N[(b / t), $MachinePrecision] + N[(a + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z / b), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x + \frac{y \cdot z}{t}}{\left(a + 1\right) + \frac{y \cdot b}{t}} \leq \infty:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \frac{z}{t}, x\right)}{\mathsf{fma}\left(y, \frac{b}{t}, a + 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 82.3%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-/.f6482.3
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6480.4
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6483.1
Applied rewrites83.1%
if +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 0.0%
Taylor expanded in y around inf
lower-/.f64100.0
Applied rewrites100.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))) (t_2 (/ (fma x t (* y z)) (* y b))))
(if (<= t -3e+100)
t_1
(if (<= t -1.8e-38)
(* y (/ z (fma a t t)))
(if (<= t -1.75e-180)
t_2
(if (<= t 2.4e-127) (/ z b) (if (<= t 5.6e-67) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double t_2 = fma(x, t, (y * z)) / (y * b);
double tmp;
if (t <= -3e+100) {
tmp = t_1;
} else if (t <= -1.8e-38) {
tmp = y * (z / fma(a, t, t));
} else if (t <= -1.75e-180) {
tmp = t_2;
} else if (t <= 2.4e-127) {
tmp = z / b;
} else if (t <= 5.6e-67) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) t_2 = Float64(fma(x, t, Float64(y * z)) / Float64(y * b)) tmp = 0.0 if (t <= -3e+100) tmp = t_1; elseif (t <= -1.8e-38) tmp = Float64(y * Float64(z / fma(a, t, t))); elseif (t <= -1.75e-180) tmp = t_2; elseif (t <= 2.4e-127) tmp = Float64(z / b); elseif (t <= 5.6e-67) tmp = t_2; else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * t + N[(y * z), $MachinePrecision]), $MachinePrecision] / N[(y * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3e+100], t$95$1, If[LessEqual[t, -1.8e-38], N[(y * N[(z / N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.75e-180], t$95$2, If[LessEqual[t, 2.4e-127], N[(z / b), $MachinePrecision], If[LessEqual[t, 5.6e-67], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
t_2 := \frac{\mathsf{fma}\left(x, t, y \cdot z\right)}{y \cdot b}\\
\mathbf{if}\;t \leq -3 \cdot 10^{+100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{-38}:\\
\;\;\;\;y \cdot \frac{z}{\mathsf{fma}\left(a, t, t\right)}\\
\mathbf{elif}\;t \leq -1.75 \cdot 10^{-180}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq 2.4 \cdot 10^{-127}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t \leq 5.6 \cdot 10^{-67}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.99999999999999985e100 or 5.60000000000000021e-67 < t Initial program 85.9%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6460.9
Applied rewrites60.9%
if -2.99999999999999985e100 < t < -1.8e-38Initial program 62.0%
Taylor expanded in y around 0
lower-fma.f64N/A
Applied rewrites51.7%
Taylor expanded in z around inf
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-fma.f6446.0
Applied rewrites46.0%
if -1.8e-38 < t < -1.75e-180 or 2.39999999999999982e-127 < t < 5.60000000000000021e-67Initial program 81.4%
Taylor expanded in b around inf
lower-/.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites56.8%
Taylor expanded in t around 0
*-commutativeN/A
lower-fma.f64N/A
lower-*.f6470.3
Applied rewrites70.3%
if -1.75e-180 < t < 2.39999999999999982e-127Initial program 53.5%
Taylor expanded in y around inf
lower-/.f6468.6
Applied rewrites68.6%
Final simplification62.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma z (/ y (fma y b (fma t a t))) (/ x a))))
(if (<= a -8.5e-19)
t_1
(if (<= a 5.2e+20) (/ (fma z (/ y t) x) (fma y (/ b t) 1.0)) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(z, (y / fma(y, b, fma(t, a, t))), (x / a));
double tmp;
if (a <= -8.5e-19) {
tmp = t_1;
} else if (a <= 5.2e+20) {
tmp = fma(z, (y / t), x) / fma(y, (b / t), 1.0);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(z, Float64(y / fma(y, b, fma(t, a, t))), Float64(x / a)) tmp = 0.0 if (a <= -8.5e-19) tmp = t_1; elseif (a <= 5.2e+20) tmp = Float64(fma(z, Float64(y / t), x) / fma(y, Float64(b / t), 1.0)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(z * N[(y / N[(y * b + N[(t * a + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x / a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8.5e-19], t$95$1, If[LessEqual[a, 5.2e+20], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(y * N[(b / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z, \frac{y}{\mathsf{fma}\left(y, b, \mathsf{fma}\left(t, a, t\right)\right)}, \frac{x}{a}\right)\\
\mathbf{if}\;a \leq -8.5 \cdot 10^{-19}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 5.2 \cdot 10^{+20}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\mathsf{fma}\left(y, \frac{b}{t}, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -8.50000000000000003e-19 or 5.2e20 < a Initial program 72.0%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites75.1%
Taylor expanded in a around inf
lower-/.f6469.4
Applied rewrites69.4%
Taylor expanded in t around 0
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6475.2
Applied rewrites75.2%
lift-fma.f64N/A
lift-fma.f64N/A
lift-/.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6477.4
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6477.4
Applied rewrites77.4%
if -8.50000000000000003e-19 < a < 5.2e20Initial program 77.3%
Taylor expanded in a around 0
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6478.9
Applied rewrites78.9%
(FPCore (x y z t a b)
:precision binary64
(if (<= t -2.05e-7)
(/ (fma y (/ z t) x) (+ a 1.0))
(if (<= t -2.25e-250)
(/ (* y z) (fma y b (fma a t t)))
(if (<= t 3.05e-57)
(/ (fma t (/ x y) z) b)
(/ (fma z (/ y t) x) (+ a 1.0))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -2.05e-7) {
tmp = fma(y, (z / t), x) / (a + 1.0);
} else if (t <= -2.25e-250) {
tmp = (y * z) / fma(y, b, fma(a, t, t));
} else if (t <= 3.05e-57) {
tmp = fma(t, (x / y), z) / b;
} else {
tmp = fma(z, (y / t), x) / (a + 1.0);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -2.05e-7) tmp = Float64(fma(y, Float64(z / t), x) / Float64(a + 1.0)); elseif (t <= -2.25e-250) tmp = Float64(Float64(y * z) / fma(y, b, fma(a, t, t))); elseif (t <= 3.05e-57) tmp = Float64(fma(t, Float64(x / y), z) / b); else tmp = Float64(fma(z, Float64(y / t), x) / Float64(a + 1.0)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -2.05e-7], N[(N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -2.25e-250], N[(N[(y * z), $MachinePrecision] / N[(y * b + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.05e-57], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.05 \cdot 10^{-7}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y, \frac{z}{t}, x\right)}{a + 1}\\
\mathbf{elif}\;t \leq -2.25 \cdot 10^{-250}:\\
\;\;\;\;\frac{y \cdot z}{\mathsf{fma}\left(y, b, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t \leq 3.05 \cdot 10^{-57}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{a + 1}\\
\end{array}
\end{array}
if t < -2.05e-7Initial program 76.9%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6482.3
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
Applied rewrites93.8%
Taylor expanded in b around 0
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f6474.2
Applied rewrites74.2%
if -2.05e-7 < t < -2.24999999999999997e-250Initial program 73.3%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites78.9%
Taylor expanded in t around 0
lower-/.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
Taylor expanded in z around inf
lower-/.f64N/A
lower-*.f64N/A
associate-+r+N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6472.2
Applied rewrites72.2%
if -2.24999999999999997e-250 < t < 3.0499999999999999e-57Initial program 58.5%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites50.8%
Taylor expanded in b around inf
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6474.6
Applied rewrites74.6%
if 3.0499999999999999e-57 < t Initial program 86.2%
Taylor expanded in b around 0
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*r/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f6473.2
Applied rewrites73.2%
Final simplification73.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (fma y (/ z t) x) (+ a 1.0))))
(if (<= t -2.05e-7)
t_1
(if (<= t -2.25e-250)
(/ (* y z) (fma y b (fma a t t)))
(if (<= t 3.05e-57) (/ (fma t (/ x y) z) b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(y, (z / t), x) / (a + 1.0);
double tmp;
if (t <= -2.05e-7) {
tmp = t_1;
} else if (t <= -2.25e-250) {
tmp = (y * z) / fma(y, b, fma(a, t, t));
} else if (t <= 3.05e-57) {
tmp = fma(t, (x / y), z) / b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(fma(y, Float64(z / t), x) / Float64(a + 1.0)) tmp = 0.0 if (t <= -2.05e-7) tmp = t_1; elseif (t <= -2.25e-250) tmp = Float64(Float64(y * z) / fma(y, b, fma(a, t, t))); elseif (t <= 3.05e-57) tmp = Float64(fma(t, Float64(x / y), z) / b); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision] / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.05e-7], t$95$1, If[LessEqual[t, -2.25e-250], N[(N[(y * z), $MachinePrecision] / N[(y * b + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.05e-57], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\mathsf{fma}\left(y, \frac{z}{t}, x\right)}{a + 1}\\
\mathbf{if}\;t \leq -2.05 \cdot 10^{-7}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -2.25 \cdot 10^{-250}:\\
\;\;\;\;\frac{y \cdot z}{\mathsf{fma}\left(y, b, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t \leq 3.05 \cdot 10^{-57}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.05e-7 or 3.0499999999999999e-57 < t Initial program 82.0%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
div-invN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f6485.4
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
Applied rewrites92.7%
Taylor expanded in b around 0
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-+.f6472.5
Applied rewrites72.5%
if -2.05e-7 < t < -2.24999999999999997e-250Initial program 73.3%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites78.9%
Taylor expanded in t around 0
lower-/.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
Taylor expanded in z around inf
lower-/.f64N/A
lower-*.f64N/A
associate-+r+N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6472.2
Applied rewrites72.2%
if -2.24999999999999997e-250 < t < 3.0499999999999999e-57Initial program 58.5%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites50.8%
Taylor expanded in b around inf
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6474.6
Applied rewrites74.6%
Final simplification72.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ 1.0 (fma b (/ y t) a)))))
(if (<= t -2.2e+55)
t_1
(if (<= t 1660000000000.0) (/ (* y z) (fma y b (fma a t t))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (1.0 + fma(b, (y / t), a));
double tmp;
if (t <= -2.2e+55) {
tmp = t_1;
} else if (t <= 1660000000000.0) {
tmp = (y * z) / fma(y, b, fma(a, t, t));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(1.0 + fma(b, Float64(y / t), a))) tmp = 0.0 if (t <= -2.2e+55) tmp = t_1; elseif (t <= 1660000000000.0) tmp = Float64(Float64(y * z) / fma(y, b, fma(a, t, t))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(1.0 + N[(b * N[(y / t), $MachinePrecision] + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.2e+55], t$95$1, If[LessEqual[t, 1660000000000.0], N[(N[(y * z), $MachinePrecision] / N[(y * b + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{1 + \mathsf{fma}\left(b, \frac{y}{t}, a\right)}\\
\mathbf{if}\;t \leq -2.2 \cdot 10^{+55}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1660000000000:\\
\;\;\;\;\frac{y \cdot z}{\mathsf{fma}\left(y, b, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.2000000000000001e55 or 1.66e12 < t Initial program 80.8%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites88.2%
Taylor expanded in z around 0
lower-/.f64N/A
lower-+.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6473.7
Applied rewrites73.7%
if -2.2000000000000001e55 < t < 1.66e12Initial program 70.4%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites68.3%
Taylor expanded in t around 0
lower-/.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6471.0
Applied rewrites71.0%
Taylor expanded in z around inf
lower-/.f64N/A
lower-*.f64N/A
associate-+r+N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6463.2
Applied rewrites63.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -8.5e+100)
t_1
(if (<= t 2.25e+17) (/ (* y z) (fma y b (fma a t t))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -8.5e+100) {
tmp = t_1;
} else if (t <= 2.25e+17) {
tmp = (y * z) / fma(y, b, fma(a, t, t));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -8.5e+100) tmp = t_1; elseif (t <= 2.25e+17) tmp = Float64(Float64(y * z) / fma(y, b, fma(a, t, t))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.5e+100], t$95$1, If[LessEqual[t, 2.25e+17], N[(N[(y * z), $MachinePrecision] / N[(y * b + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -8.5 \cdot 10^{+100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2.25 \cdot 10^{+17}:\\
\;\;\;\;\frac{y \cdot z}{\mathsf{fma}\left(y, b, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -8.50000000000000043e100 or 2.25e17 < t Initial program 84.9%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6468.5
Applied rewrites68.5%
if -8.50000000000000043e100 < t < 2.25e17Initial program 68.8%
Taylor expanded in x around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
lower-+.f64N/A
Applied rewrites69.2%
Taylor expanded in t around 0
lower-/.f64N/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6471.7
Applied rewrites71.7%
Taylor expanded in z around inf
lower-/.f64N/A
lower-*.f64N/A
associate-+r+N/A
*-lft-identityN/A
distribute-rgt-inN/A
+-commutativeN/A
*-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6460.0
Applied rewrites60.0%
Final simplification63.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ a 1.0))))
(if (<= t -3e+100)
t_1
(if (<= t -1.3e-95)
(* y (/ z (fma a t t)))
(if (<= t 3.2e-56) (/ z b) t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -3e+100) {
tmp = t_1;
} else if (t <= -1.3e-95) {
tmp = y * (z / fma(a, t, t));
} else if (t <= 3.2e-56) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -3e+100) tmp = t_1; elseif (t <= -1.3e-95) tmp = Float64(y * Float64(z / fma(a, t, t))); elseif (t <= 3.2e-56) tmp = Float64(z / b); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3e+100], t$95$1, If[LessEqual[t, -1.3e-95], N[(y * N[(z / N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.2e-56], N[(z / b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -3 \cdot 10^{+100}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -1.3 \cdot 10^{-95}:\\
\;\;\;\;y \cdot \frac{z}{\mathsf{fma}\left(a, t, t\right)}\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{-56}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.99999999999999985e100 or 3.19999999999999986e-56 < t Initial program 86.4%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6461.5
Applied rewrites61.5%
if -2.99999999999999985e100 < t < -1.3e-95Initial program 67.3%
Taylor expanded in y around 0
lower-fma.f64N/A
Applied rewrites50.1%
Taylor expanded in z around inf
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-fma.f6445.5
Applied rewrites45.5%
if -1.3e-95 < t < 3.19999999999999986e-56Initial program 63.6%
Taylor expanded in y around inf
lower-/.f6458.6
Applied rewrites58.6%
Final simplification58.2%
(FPCore (x y z t a b) :precision binary64 (if (<= t -3.5e+236) x (if (<= t -6.5e+77) (/ x a) (if (<= t 3.75e-56) (/ z b) x))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -3.5e+236) {
tmp = x;
} else if (t <= -6.5e+77) {
tmp = x / a;
} else if (t <= 3.75e-56) {
tmp = z / b;
} else {
tmp = x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if (t <= (-3.5d+236)) then
tmp = x
else if (t <= (-6.5d+77)) then
tmp = x / a
else if (t <= 3.75d-56) then
tmp = z / b
else
tmp = x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (t <= -3.5e+236) {
tmp = x;
} else if (t <= -6.5e+77) {
tmp = x / a;
} else if (t <= 3.75e-56) {
tmp = z / b;
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if t <= -3.5e+236: tmp = x elif t <= -6.5e+77: tmp = x / a elif t <= 3.75e-56: tmp = z / b else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (t <= -3.5e+236) tmp = x; elseif (t <= -6.5e+77) tmp = Float64(x / a); elseif (t <= 3.75e-56) tmp = Float64(z / b); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (t <= -3.5e+236) tmp = x; elseif (t <= -6.5e+77) tmp = x / a; elseif (t <= 3.75e-56) tmp = z / b; else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[t, -3.5e+236], x, If[LessEqual[t, -6.5e+77], N[(x / a), $MachinePrecision], If[LessEqual[t, 3.75e-56], N[(z / b), $MachinePrecision], x]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -3.5 \cdot 10^{+236}:\\
\;\;\;\;x\\
\mathbf{elif}\;t \leq -6.5 \cdot 10^{+77}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t \leq 3.75 \cdot 10^{-56}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if t < -3.49999999999999979e236 or 3.75000000000000021e-56 < t Initial program 86.7%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6457.9
Applied rewrites57.9%
Taylor expanded in a around 0
Applied rewrites35.3%
if -3.49999999999999979e236 < t < -6.5e77Initial program 80.0%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6462.5
Applied rewrites62.5%
Taylor expanded in a around inf
lower-/.f6443.7
Applied rewrites43.7%
if -6.5e77 < t < 3.75000000000000021e-56Initial program 64.8%
Taylor expanded in y around inf
lower-/.f6454.0
Applied rewrites54.0%
Final simplification45.8%
(FPCore (x y z t a b) :precision binary64 (if (<= (+ a 1.0) -5000000.0) (/ x a) (if (<= (+ a 1.0) 1.00005) x (/ x a))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a + 1.0) <= -5000000.0) {
tmp = x / a;
} else if ((a + 1.0) <= 1.00005) {
tmp = x;
} else {
tmp = x / a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: tmp
if ((a + 1.0d0) <= (-5000000.0d0)) then
tmp = x / a
else if ((a + 1.0d0) <= 1.00005d0) then
tmp = x
else
tmp = x / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if ((a + 1.0) <= -5000000.0) {
tmp = x / a;
} else if ((a + 1.0) <= 1.00005) {
tmp = x;
} else {
tmp = x / a;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if (a + 1.0) <= -5000000.0: tmp = x / a elif (a + 1.0) <= 1.00005: tmp = x else: tmp = x / a return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (Float64(a + 1.0) <= -5000000.0) tmp = Float64(x / a); elseif (Float64(a + 1.0) <= 1.00005) tmp = x; else tmp = Float64(x / a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if ((a + 1.0) <= -5000000.0) tmp = x / a; elseif ((a + 1.0) <= 1.00005) tmp = x; else tmp = x / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[(a + 1.0), $MachinePrecision], -5000000.0], N[(x / a), $MachinePrecision], If[LessEqual[N[(a + 1.0), $MachinePrecision], 1.00005], x, N[(x / a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a + 1 \leq -5000000:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;a + 1 \leq 1.00005:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a}\\
\end{array}
\end{array}
if (+.f64 a #s(literal 1 binary64)) < -5e6 or 1.00005000000000011 < (+.f64 a #s(literal 1 binary64)) Initial program 73.2%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6441.2
Applied rewrites41.2%
Taylor expanded in a around inf
lower-/.f6440.0
Applied rewrites40.0%
if -5e6 < (+.f64 a #s(literal 1 binary64)) < 1.00005000000000011Initial program 76.4%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6430.6
Applied rewrites30.6%
Taylor expanded in a around 0
Applied rewrites30.6%
Final simplification35.1%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ x (+ a 1.0)))) (if (<= t -2.85e+76) t_1 (if (<= t 3.2e-56) (/ z b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -2.85e+76) {
tmp = t_1;
} else if (t <= 3.2e-56) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = x / (a + 1.0d0)
if (t <= (-2.85d+76)) then
tmp = t_1
else if (t <= 3.2d-56) then
tmp = z / b
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (a + 1.0);
double tmp;
if (t <= -2.85e+76) {
tmp = t_1;
} else if (t <= 3.2e-56) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (a + 1.0) tmp = 0 if t <= -2.85e+76: tmp = t_1 elif t <= 3.2e-56: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(a + 1.0)) tmp = 0.0 if (t <= -2.85e+76) tmp = t_1; elseif (t <= 3.2e-56) tmp = Float64(z / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x / (a + 1.0); tmp = 0.0; if (t <= -2.85e+76) tmp = t_1; elseif (t <= 3.2e-56) tmp = z / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(a + 1.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.85e+76], t$95$1, If[LessEqual[t, 3.2e-56], N[(z / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{a + 1}\\
\mathbf{if}\;t \leq -2.85 \cdot 10^{+76}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 3.2 \cdot 10^{-56}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.85000000000000002e76 or 3.19999999999999986e-56 < t Initial program 85.0%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6459.1
Applied rewrites59.1%
if -2.85000000000000002e76 < t < 3.19999999999999986e-56Initial program 64.8%
Taylor expanded in y around inf
lower-/.f6454.0
Applied rewrites54.0%
Final simplification56.6%
(FPCore (x y z t a b) :precision binary64 (- x (* x a)))
double code(double x, double y, double z, double t, double a, double b) {
return x - (x * a);
}
real(8) function code(x, y, z, t, a, b)
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
code = x - (x * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x - (x * a);
}
def code(x, y, z, t, a, b): return x - (x * a)
function code(x, y, z, t, a, b) return Float64(x - Float64(x * a)) end
function tmp = code(x, y, z, t, a, b) tmp = x - (x * a); end
code[x_, y_, z_, t_, a_, b_] := N[(x - N[(x * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - x \cdot a
\end{array}
Initial program 74.9%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6435.7
Applied rewrites35.7%
Taylor expanded in a around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f6417.5
Applied rewrites17.5%
(FPCore (x y z t a b) :precision binary64 (- (* x a)))
double code(double x, double y, double z, double t, double a, double b) {
return -(x * a);
}
real(8) function code(x, y, z, t, a, b)
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
code = -(x * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return -(x * a);
}
def code(x, y, z, t, a, b): return -(x * a)
function code(x, y, z, t, a, b) return Float64(-Float64(x * a)) end
function tmp = code(x, y, z, t, a, b) tmp = -(x * a); end
code[x_, y_, z_, t_, a_, b_] := (-N[(x * a), $MachinePrecision])
\begin{array}{l}
\\
-x \cdot a
\end{array}
Initial program 74.9%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6435.7
Applied rewrites35.7%
Taylor expanded in a around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f6417.5
Applied rewrites17.5%
Taylor expanded in a around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f645.1
Applied rewrites5.1%
Final simplification5.1%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
real(8) function code(x, y, z, t, a, b)
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
code = x
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 74.9%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6435.7
Applied rewrites35.7%
Taylor expanded in a around 0
Applied rewrites17.9%
Final simplification17.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1
(* 1.0 (* (+ x (* (/ y t) z)) (/ 1.0 (+ (+ a 1.0) (* (/ y t) b)))))))
(if (< t -1.3659085366310088e-271)
t_1
(if (< t 3.036967103737246e-130) (/ z b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b))));
double tmp;
if (t < -1.3659085366310088e-271) {
tmp = t_1;
} else if (t < 3.036967103737246e-130) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
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) :: t_1
real(8) :: tmp
t_1 = 1.0d0 * ((x + ((y / t) * z)) * (1.0d0 / ((a + 1.0d0) + ((y / t) * b))))
if (t < (-1.3659085366310088d-271)) then
tmp = t_1
else if (t < 3.036967103737246d-130) then
tmp = z / b
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b))));
double tmp;
if (t < -1.3659085366310088e-271) {
tmp = t_1;
} else if (t < 3.036967103737246e-130) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b)))) tmp = 0 if t < -1.3659085366310088e-271: tmp = t_1 elif t < 3.036967103737246e-130: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(1.0 * Float64(Float64(x + Float64(Float64(y / t) * z)) * Float64(1.0 / Float64(Float64(a + 1.0) + Float64(Float64(y / t) * b))))) tmp = 0.0 if (t < -1.3659085366310088e-271) tmp = t_1; elseif (t < 3.036967103737246e-130) tmp = Float64(z / b); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = 1.0 * ((x + ((y / t) * z)) * (1.0 / ((a + 1.0) + ((y / t) * b)))); tmp = 0.0; if (t < -1.3659085366310088e-271) tmp = t_1; elseif (t < 3.036967103737246e-130) tmp = z / b; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(1.0 * N[(N[(x + N[(N[(y / t), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[(a + 1.0), $MachinePrecision] + N[(N[(y / t), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -1.3659085366310088e-271], t$95$1, If[Less[t, 3.036967103737246e-130], N[(z / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 1 \cdot \left(\left(x + \frac{y}{t} \cdot z\right) \cdot \frac{1}{\left(a + 1\right) + \frac{y}{t} \cdot b}\right)\\
\mathbf{if}\;t < -1.3659085366310088 \cdot 10^{-271}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < 3.036967103737246 \cdot 10^{-130}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
herbie shell --seed 2024219
(FPCore (x y z t a b)
:name "Diagrams.Solve.Tridiagonal:solveCyclicTriDiagonal from diagrams-solve-0.1, B"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1707385670788761/12500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (* 1 (* (+ x (* (/ y t) z)) (/ 1 (+ (+ a 1) (* (/ y t) b))))) (if (< t 1518483551868623/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (/ z b) (* 1 (* (+ x (* (/ y t) z)) (/ 1 (+ (+ a 1) (* (/ y t) b))))))))
(/ (+ x (/ (* y z) t)) (+ (+ a 1.0) (/ (* y b) t))))