
(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 20 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 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (fma (/ y t) b (+ 1.0 a)))
(t_3 (fma (/ b t) y a)))
(if (<= t_1 -5e+277)
(* (+ (/ x (fma z t_3 z)) (/ y (fma t_3 t t))) z)
(if (<= t_1 -4e-321)
(/ (fma z (/ y t) x) (+ (/ b (/ t y)) (+ 1.0 a)))
(if (<= t_1 0.0)
(+ (/ z b) (/ (* (- (/ x b) (/ (/ (fma z a z) b) b)) t) y))
(if (<= t_1 INFINITY)
(fma (/ z t_2) (/ y t) (/ x t_2))
(/ (fma t (/ x y) z) b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = fma((y / t), b, (1.0 + a));
double t_3 = fma((b / t), y, a);
double tmp;
if (t_1 <= -5e+277) {
tmp = ((x / fma(z, t_3, z)) + (y / fma(t_3, t, t))) * z;
} else if (t_1 <= -4e-321) {
tmp = fma(z, (y / t), x) / ((b / (t / y)) + (1.0 + a));
} else if (t_1 <= 0.0) {
tmp = (z / b) + ((((x / b) - ((fma(z, a, z) / b) / b)) * t) / y);
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma((z / t_2), (y / t), (x / t_2));
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_2 = fma(Float64(y / t), b, Float64(1.0 + a)) t_3 = fma(Float64(b / t), y, a) tmp = 0.0 if (t_1 <= -5e+277) tmp = Float64(Float64(Float64(x / fma(z, t_3, z)) + Float64(y / fma(t_3, t, t))) * z); elseif (t_1 <= -4e-321) tmp = Float64(fma(z, Float64(y / t), x) / Float64(Float64(b / Float64(t / y)) + Float64(1.0 + a))); elseif (t_1 <= 0.0) tmp = Float64(Float64(z / b) + Float64(Float64(Float64(Float64(x / b) - Float64(Float64(fma(z, a, z) / b) / b)) * t) / y)); elseif (t_1 <= Inf) tmp = fma(Float64(z / t_2), Float64(y / t), Float64(x / t_2)); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / t), $MachinePrecision] * b + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+277], N[(N[(N[(x / N[(z * t$95$3 + z), $MachinePrecision]), $MachinePrecision] + N[(y / N[(t$95$3 * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -4e-321], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(b / N[(t / y), $MachinePrecision]), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(N[(z / b), $MachinePrecision] + N[(N[(N[(N[(x / b), $MachinePrecision] - N[(N[(N[(z * a + z), $MachinePrecision] / b), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z / t$95$2), $MachinePrecision] * N[(y / t), $MachinePrecision] + N[(x / t$95$2), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_2 := \mathsf{fma}\left(\frac{y}{t}, b, 1 + a\right)\\
t_3 := \mathsf{fma}\left(\frac{b}{t}, y, a\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+277}:\\
\;\;\;\;\left(\frac{x}{\mathsf{fma}\left(z, t\_3, z\right)} + \frac{y}{\mathsf{fma}\left(t\_3, t, t\right)}\right) \cdot z\\
\mathbf{elif}\;t\_1 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\frac{b}{\frac{t}{y}} + \left(1 + a\right)}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b} + \frac{\left(\frac{x}{b} - \frac{\frac{\mathsf{fma}\left(z, a, z\right)}{b}}{b}\right) \cdot t}{y}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{t\_2}, \frac{y}{t}, \frac{x}{t\_2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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))) < -4.99999999999999982e277Initial program 27.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites94.0%
if -4.99999999999999982e277 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -4.00193e-321Initial program 98.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.2
Applied rewrites99.2%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6499.3
Applied rewrites99.3%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0Initial program 47.7%
Taylor expanded in t around 0
lower-+.f64N/A
Applied rewrites71.5%
if -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 88.8%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6470.8
Applied rewrites70.8%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6475.5
Applied rewrites75.5%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites93.3%
Applied rewrites96.0%
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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification92.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (fma (- x) a x)))
(if (<= t_1 (- INFINITY))
(/ z b)
(if (<= t_1 -1e-197)
t_2
(if (<= t_1 0.0)
(/ z b)
(if (<= t_1 1e+16) (/ x a) (if (<= t_1 2e+288) t_2 (/ z b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = fma(-x, a, x);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = z / b;
} else if (t_1 <= -1e-197) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 1e+16) {
tmp = x / a;
} else if (t_1 <= 2e+288) {
tmp = t_2;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_2 = fma(Float64(-x), a, x) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(z / b); elseif (t_1 <= -1e-197) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 1e+16) tmp = Float64(x / a); elseif (t_1 <= 2e+288) tmp = t_2; else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-x) * a + x), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, -1e-197], t$95$2, If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 1e+16], N[(x / a), $MachinePrecision], If[LessEqual[t$95$1, 2e+288], t$95$2, N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_2 := \mathsf{fma}\left(-x, a, x\right)\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{-197}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 10^{+16}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+288}:\\
\;\;\;\;t\_2\\
\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 -9.9999999999999999e-198 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0 or 2e288 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 35.9%
Taylor expanded in t around 0
lower-/.f6461.3
Applied rewrites61.3%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -9.9999999999999999e-198 or 1e16 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2e288Initial program 98.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.3
Applied rewrites99.3%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6459.1
Applied rewrites59.1%
Taylor expanded in a around 0
Applied rewrites41.6%
if -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 1e16Initial program 96.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.6
Applied rewrites99.6%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6449.6
Applied rewrites49.6%
Taylor expanded in a around inf
Applied rewrites38.5%
Final simplification49.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* b y) t) (+ 1.0 a)))
(t_2 (/ (fma z (/ y t) x) t_1))
(t_3 (/ (+ (/ (* z y) t) x) t_1)))
(if (<= t_3 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_3 -4e-321)
t_2
(if (<= t_3 0.0)
(fma t (/ x (* b y)) (/ z b))
(if (<= t_3 INFINITY) t_2 (/ (fma t (/ x y) z) b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((b * y) / t) + (1.0 + a);
double t_2 = fma(z, (y / t), x) / t_1;
double t_3 = (((z * y) / t) + x) / t_1;
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_3 <= -4e-321) {
tmp = t_2;
} else if (t_3 <= 0.0) {
tmp = fma(t, (x / (b * y)), (z / b));
} else if (t_3 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a)) t_2 = Float64(fma(z, Float64(y / t), x) / t_1) t_3 = Float64(Float64(Float64(Float64(z * y) / t) + x) / t_1) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_3 <= -4e-321) tmp = t_2; elseif (t_3 <= 0.0) tmp = fma(t, Float64(x / Float64(b * y)), Float64(z / b)); elseif (t_3 <= Inf) tmp = t_2; else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$3, -4e-321], t$95$2, If[LessEqual[t$95$3, 0.0], N[(t * N[(x / N[(b * y), $MachinePrecision]), $MachinePrecision] + N[(z / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], t$95$2, N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{b \cdot y}{t} + \left(1 + a\right)\\
t_2 := \frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{t\_1}\\
t_3 := \frac{\frac{z \cdot y}{t} + x}{t\_1}\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_3 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{x}{b \cdot y}, \frac{z}{b}\right)\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.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.00193e-321 or -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 92.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6496.3
Applied rewrites96.3%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0Initial program 47.7%
Taylor expanded in b around inf
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.4
Applied rewrites28.4%
Taylor expanded in t around 0
Applied rewrites69.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification91.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_1 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_1 -4e-321)
(/ (+ (/ z (/ t y)) x) (+ 1.0 a))
(if (<= t_1 0.0)
(fma t (/ x (* b y)) (/ z b))
(if (<= t_1 INFINITY)
(/ (fma (/ y t) z x) (+ 1.0 a))
(/ (fma t (/ x y) z) b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_1 <= -4e-321) {
tmp = ((z / (t / y)) + x) / (1.0 + a);
} else if (t_1 <= 0.0) {
tmp = fma(t, (x / (b * y)), (z / b));
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma((y / t), z, x) / (1.0 + a);
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_1 <= -4e-321) tmp = Float64(Float64(Float64(z / Float64(t / y)) + x) / Float64(1.0 + a)); elseif (t_1 <= 0.0) tmp = fma(t, Float64(x / Float64(b * y)), Float64(z / b)); elseif (t_1 <= Inf) tmp = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -4e-321], N[(N[(N[(z / N[(t / y), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(t * N[(x / N[(b * y), $MachinePrecision]), $MachinePrecision] + N[(z / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;\frac{\frac{z}{\frac{t}{y}} + x}{1 + a}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{x}{b \cdot y}, \frac{z}{b}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.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.00193e-321Initial program 98.4%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6477.7
Applied rewrites77.7%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r/N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6478.7
Applied rewrites78.7%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0Initial program 47.7%
Taylor expanded in b around inf
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.4
Applied rewrites28.4%
Taylor expanded in t around 0
Applied rewrites69.4%
if -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 88.8%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6470.8
Applied rewrites70.8%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6475.5
Applied rewrites75.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification77.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (fma (/ y t) z x) (+ 1.0 a)))
(t_2 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_2 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_2 -4e-321)
t_1
(if (<= t_2 0.0)
(fma t (/ x (* b y)) (/ z b))
(if (<= t_2 INFINITY) t_1 (/ (fma t (/ x y) z) b)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma((y / t), z, x) / (1.0 + a);
double t_2 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_2 <= -4e-321) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = fma(t, (x / (b * y)), (z / b));
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)) t_2 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_2 <= -4e-321) tmp = t_1; elseif (t_2 <= 0.0) tmp = fma(t, Float64(x / Float64(b * y)), Float64(z / b)); elseif (t_2 <= Inf) tmp = t_1; else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$2, -4e-321], t$95$1, If[LessEqual[t$95$2, 0.0], N[(t * N[(x / N[(b * y), $MachinePrecision]), $MachinePrecision] + N[(z / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$1, N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_2 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{x}{b \cdot y}, \frac{z}{b}\right)\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.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.00193e-321 or -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 92.6%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6473.6
Applied rewrites73.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6476.7
Applied rewrites76.7%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0Initial program 47.7%
Taylor expanded in b around inf
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.4
Applied rewrites28.4%
Taylor expanded in t around 0
Applied rewrites69.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification77.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (fma (/ b t) y a))
(t_2 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_3 (* (+ (/ x (fma z t_1 z)) (/ y (fma t_1 t t))) z)))
(if (<= t_2 -5e+277)
t_3
(if (<= t_2 2e+288)
(/ (fma z (/ y t) x) (+ (/ b (/ t y)) (+ 1.0 a)))
(if (<= t_2 INFINITY) t_3 (/ (fma t (/ x y) z) b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma((b / t), y, a);
double t_2 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_3 = ((x / fma(z, t_1, z)) + (y / fma(t_1, t, t))) * z;
double tmp;
if (t_2 <= -5e+277) {
tmp = t_3;
} else if (t_2 <= 2e+288) {
tmp = fma(z, (y / t), x) / ((b / (t / y)) + (1.0 + a));
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_3;
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(Float64(b / t), y, a) t_2 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_3 = Float64(Float64(Float64(x / fma(z, t_1, z)) + Float64(y / fma(t_1, t, t))) * z) tmp = 0.0 if (t_2 <= -5e+277) tmp = t_3; elseif (t_2 <= 2e+288) tmp = Float64(fma(z, Float64(y / t), x) / Float64(Float64(b / Float64(t / y)) + Float64(1.0 + a))); elseif (t_2 <= Inf) tmp = t_3; else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(x / N[(z * t$95$1 + z), $MachinePrecision]), $MachinePrecision] + N[(y / N[(t$95$1 * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+277], t$95$3, If[LessEqual[t$95$2, 2e+288], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(b / N[(t / y), $MachinePrecision]), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$3, N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{b}{t}, y, a\right)\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_3 := \left(\frac{x}{\mathsf{fma}\left(z, t\_1, z\right)} + \frac{y}{\mathsf{fma}\left(t\_1, t, t\right)}\right) \cdot z\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+277}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+288}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\frac{b}{\frac{t}{y}} + \left(1 + a\right)}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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))) < -4.99999999999999982e277 or 2e288 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites94.1%
if -4.99999999999999982e277 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2e288Initial program 88.0%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6487.1
Applied rewrites87.1%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6490.1
Applied rewrites90.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification90.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (fma b (/ y t) a)))
(if (<= t_1 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_1 2e+161)
(/ (fma z (/ y t) x) (+ (/ b (/ t y)) (+ 1.0 a)))
(if (<= t_1 INFINITY)
(fma y (/ z (fma t_2 t t)) (/ x (+ t_2 1.0)))
(/ (fma t (/ x y) z) b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = fma(b, (y / t), a);
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_1 <= 2e+161) {
tmp = fma(z, (y / t), x) / ((b / (t / y)) + (1.0 + a));
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma(y, (z / fma(t_2, t, t)), (x / (t_2 + 1.0)));
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_2 = fma(b, Float64(y / t), a) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_1 <= 2e+161) tmp = Float64(fma(z, Float64(y / t), x) / Float64(Float64(b / Float64(t / y)) + Float64(1.0 + a))); elseif (t_1 <= Inf) tmp = fma(y, Float64(z / fma(t_2, t, t)), Float64(x / Float64(t_2 + 1.0))); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(y / t), $MachinePrecision] + a), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, 2e+161], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(b / N[(t / y), $MachinePrecision]), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(y * N[(z / N[(t$95$2 * t + t), $MachinePrecision]), $MachinePrecision] + N[(x / N[(t$95$2 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_2 := \mathsf{fma}\left(b, \frac{y}{t}, a\right)\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\frac{b}{\frac{t}{y}} + \left(1 + a\right)}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(t\_2, t, t\right)}, \frac{x}{t\_2 + 1}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.9%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.0000000000000001e161Initial program 87.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6486.3
Applied rewrites86.3%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6489.4
Applied rewrites89.4%
if 2.0000000000000001e161 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 69.9%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6459.9
Applied rewrites59.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6472.1
Applied rewrites72.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites93.7%
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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification89.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_1 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_1 2e+161)
(/ (fma z (/ y t) x) (+ (/ b (/ t y)) (+ 1.0 a)))
(if (<= t_1 INFINITY)
(fma
y
(/ z (fma (fma b (/ y t) a) t t))
(/ x (fma b (/ y t) (+ 1.0 a))))
(/ (fma t (/ x y) z) b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_1 <= 2e+161) {
tmp = fma(z, (y / t), x) / ((b / (t / y)) + (1.0 + a));
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma(y, (z / fma(fma(b, (y / t), a), t, t)), (x / fma(b, (y / t), (1.0 + a))));
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_1 <= 2e+161) tmp = Float64(fma(z, Float64(y / t), x) / Float64(Float64(b / Float64(t / y)) + Float64(1.0 + a))); elseif (t_1 <= Inf) tmp = fma(y, Float64(z / fma(fma(b, Float64(y / t), a), t, t)), Float64(x / fma(b, Float64(y / t), Float64(1.0 + a)))); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, 2e+161], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(b / N[(t / y), $MachinePrecision]), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(y * N[(z / N[(N[(b * N[(y / t), $MachinePrecision] + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] + N[(x / N[(b * N[(y / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+161}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\frac{b}{\frac{t}{y}} + \left(1 + a\right)}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{z}{\mathsf{fma}\left(\mathsf{fma}\left(b, \frac{y}{t}, a\right), t, t\right)}, \frac{x}{\mathsf{fma}\left(b, \frac{y}{t}, 1 + a\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.9%
if -inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.0000000000000001e161Initial program 87.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6486.3
Applied rewrites86.3%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6489.4
Applied rewrites89.4%
if 2.0000000000000001e161 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 69.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6482.1
Applied rewrites82.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
Applied rewrites93.7%
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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification89.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (/ (fma (/ y t) z x) (+ 1.0 a))))
(if (<= t_1 -4e-321)
t_2
(if (<= t_1 0.0)
(fma t (/ x (* b y)) (/ z b))
(if (<= t_1 INFINITY) t_2 (/ (fma t (/ x y) z) b))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = fma((y / t), z, x) / (1.0 + a);
double tmp;
if (t_1 <= -4e-321) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = fma(t, (x / (b * y)), (z / b));
} else if (t_1 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_2 = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -4e-321) tmp = t_2; elseif (t_1 <= 0.0) tmp = fma(t, Float64(x / Float64(b * y)), Float64(z / b)); elseif (t_1 <= Inf) tmp = t_2; else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -4e-321], t$95$2, If[LessEqual[t$95$1, 0.0], N[(t * N[(x / N[(b * y), $MachinePrecision]), $MachinePrecision] + N[(z / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], t$95$2, N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_2 := \frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\mathbf{if}\;t\_1 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\mathsf{fma}\left(t, \frac{x}{b \cdot y}, \frac{z}{b}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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))) < -4.00193e-321 or -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 86.7%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6469.0
Applied rewrites69.0%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6473.3
Applied rewrites73.3%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0Initial program 47.7%
Taylor expanded in b around inf
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6428.4
Applied rewrites28.4%
Taylor expanded in t around 0
Applied rewrites69.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification74.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (fma t (/ x y) z) b))
(t_2 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_3 (/ (fma (/ y t) z x) (+ 1.0 a))))
(if (<= t_2 -4e-321)
t_3
(if (<= t_2 0.0) t_1 (if (<= t_2 INFINITY) t_3 t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(t, (x / y), z) / b;
double t_2 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_3 = fma((y / t), z, x) / (1.0 + a);
double tmp;
if (t_2 <= -4e-321) {
tmp = t_3;
} else if (t_2 <= 0.0) {
tmp = t_1;
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(fma(t, Float64(x / y), z) / b) t_2 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_3 = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)) tmp = 0.0 if (t_2 <= -4e-321) tmp = t_3; elseif (t_2 <= 0.0) tmp = t_1; elseif (t_2 <= Inf) tmp = t_3; else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -4e-321], t$95$3, If[LessEqual[t$95$2, 0.0], t$95$1, If[LessEqual[t$95$2, Infinity], t$95$3, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_3 := \frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\mathbf{if}\;t\_2 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\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))) < -4.00193e-321 or -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 86.7%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6469.0
Applied rewrites69.0%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6473.3
Applied rewrites73.3%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0 or +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 27.5%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6421.7
Applied rewrites21.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6424.8
Applied rewrites24.8%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites39.1%
Taylor expanded in b around inf
Applied rewrites77.8%
Final simplification74.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (fma t (/ x y) z) b))
(t_2 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_3 (/ (fma (/ z t) y x) (+ 1.0 a))))
(if (<= t_2 -4e-321)
t_3
(if (<= t_2 0.0) t_1 (if (<= t_2 INFINITY) t_3 t_1)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(t, (x / y), z) / b;
double t_2 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_3 = fma((z / t), y, x) / (1.0 + a);
double tmp;
if (t_2 <= -4e-321) {
tmp = t_3;
} else if (t_2 <= 0.0) {
tmp = t_1;
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(fma(t, Float64(x / y), z) / b) t_2 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_3 = Float64(fma(Float64(z / t), y, x) / Float64(1.0 + a)) tmp = 0.0 if (t_2 <= -4e-321) tmp = t_3; elseif (t_2 <= 0.0) tmp = t_1; elseif (t_2 <= Inf) tmp = t_3; else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(z / t), $MachinePrecision] * y + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -4e-321], t$95$3, If[LessEqual[t$95$2, 0.0], t$95$1, If[LessEqual[t$95$2, Infinity], t$95$3, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_3 := \frac{\mathsf{fma}\left(\frac{z}{t}, y, x\right)}{1 + a}\\
\mathbf{if}\;t\_2 \leq -4 \cdot 10^{-321}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\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))) < -4.00193e-321 or -0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 86.7%
Taylor expanded in b around 0
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6468.9
Applied rewrites68.9%
if -4.00193e-321 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -0.0 or +inf.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 27.5%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6421.7
Applied rewrites21.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6424.8
Applied rewrites24.8%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites39.1%
Taylor expanded in b around inf
Applied rewrites77.8%
Final simplification71.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_1 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_1 INFINITY)
(/ (fma z (/ y t) x) (+ (/ b (/ t y)) (+ 1.0 a)))
(/ (fma t (/ x y) z) b)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma(z, (y / t), x) / ((b / (t / y)) + (1.0 + a));
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_1 <= Inf) tmp = Float64(fma(z, Float64(y / t), x) / Float64(Float64(b / Float64(t / y)) + Float64(1.0 + a))); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(b / N[(t / y), $MachinePrecision]), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{\frac{b}{\frac{t}{y}} + \left(1 + a\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.9%
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 84.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.6
Applied rewrites85.6%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6487.9
Applied rewrites87.9%
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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification88.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_1 (- INFINITY))
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(if (<= t_1 INFINITY)
(/ (fma (/ z t) y x) (fma (/ b t) y (+ 1.0 a)))
(/ (fma t (/ x y) z) b)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else if (t_1 <= ((double) INFINITY)) {
tmp = fma((z / t), y, x) / fma((b / t), y, (1.0 + a));
} else {
tmp = fma(t, (x / y), z) / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(Float64(z * y) / t) + x) / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); elseif (t_1 <= Inf) tmp = Float64(fma(Float64(z / t), y, x) / fma(Float64(b / t), y, Float64(1.0 + a))); else tmp = Float64(fma(t, Float64(x / y), z) / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[(z / t), $MachinePrecision] * y + x), $MachinePrecision] / N[(N[(b / t), $MachinePrecision] * y + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{z \cdot y}{t} + x}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{z}{t}, y, x\right)}{\mathsf{fma}\left(\frac{b}{t}, y, 1 + a\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{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 17.8%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites86.9%
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 84.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6482.3
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6483.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6483.2
Applied rewrites83.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 b around 0
+-commutativeN/A
lower-+.f645.1
Applied rewrites5.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6415.9
Applied rewrites15.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites10.2%
Taylor expanded in b around inf
Applied rewrites90.0%
Final simplification84.2%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ x (fma (/ b t) y (+ 1.0 a))))) (if (<= t -6e-78) t_1 (if (<= t 6.6e-42) (/ (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 = x / fma((b / t), y, (1.0 + a));
double tmp;
if (t <= -6e-78) {
tmp = t_1;
} else if (t <= 6.6e-42) {
tmp = fma(t, (x / y), z) / b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / fma(Float64(b / t), y, Float64(1.0 + a))) tmp = 0.0 if (t <= -6e-78) tmp = t_1; elseif (t <= 6.6e-42) 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[(x / N[(N[(b / t), $MachinePrecision] * y + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6e-78], t$95$1, If[LessEqual[t, 6.6e-42], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{\mathsf{fma}\left(\frac{b}{t}, y, 1 + a\right)}\\
\mathbf{if}\;t \leq -6 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 6.6 \cdot 10^{-42}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -5.99999999999999975e-78 or 6.6000000000000005e-42 < t Initial program 81.8%
Taylor expanded in z around 0
lower-/.f64N/A
associate-+r+N/A
+-commutativeN/A
remove-double-negN/A
associate-/l*N/A
distribute-rgt-neg-outN/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
associate-*r*N/A
*-commutativeN/A
*-commutativeN/A
mul-1-negN/A
distribute-lft-neg-outN/A
remove-double-negN/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6468.8
Applied rewrites68.8%
if -5.99999999999999975e-78 < t < 6.6000000000000005e-42Initial program 56.5%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6437.9
Applied rewrites37.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6438.9
Applied rewrites38.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites60.8%
Taylor expanded in b around inf
Applied rewrites60.4%
Final simplification65.4%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (fma (/ y t) z x)) (t_2 (/ t_1 a))) (if (<= a -1.0) t_2 (if (<= a 1.0) (/ t_1 1.0) t_2))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma((y / t), z, x);
double t_2 = t_1 / a;
double tmp;
if (a <= -1.0) {
tmp = t_2;
} else if (a <= 1.0) {
tmp = t_1 / 1.0;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(Float64(y / t), z, x) t_2 = Float64(t_1 / a) tmp = 0.0 if (a <= -1.0) tmp = t_2; elseif (a <= 1.0) tmp = Float64(t_1 / 1.0); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / a), $MachinePrecision]}, If[LessEqual[a, -1.0], t$95$2, If[LessEqual[a, 1.0], N[(t$95$1 / 1.0), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y}{t}, z, x\right)\\
t_2 := \frac{t\_1}{a}\\
\mathbf{if}\;a \leq -1:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 1:\\
\;\;\;\;\frac{t\_1}{1}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -1 or 1 < a Initial program 70.2%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6459.9
Applied rewrites59.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6464.0
Applied rewrites64.0%
Taylor expanded in a around inf
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6458.1
Applied rewrites58.1%
Applied rewrites63.8%
if -1 < a < 1Initial program 72.8%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6453.4
Applied rewrites53.4%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6457.2
Applied rewrites57.2%
Taylor expanded in a around 0
Applied rewrites55.9%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ x (+ 1.0 a)))) (if (<= t -9.2e-6) t_1 (if (<= t 1.9e-18) (/ (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 = x / (1.0 + a);
double tmp;
if (t <= -9.2e-6) {
tmp = t_1;
} else if (t <= 1.9e-18) {
tmp = fma(t, (x / y), z) / b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t <= -9.2e-6) tmp = t_1; elseif (t <= 1.9e-18) 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[(x / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -9.2e-6], t$95$1, If[LessEqual[t, 1.9e-18], N[(N[(t * N[(x / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{1 + a}\\
\mathbf{if}\;t \leq -9.2 \cdot 10^{-6}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{-18}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t, \frac{x}{y}, z\right)}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -9.2e-6 or 1.8999999999999999e-18 < t Initial program 81.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6459.9
Applied rewrites59.9%
if -9.2e-6 < t < 1.8999999999999999e-18Initial program 60.1%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6440.2
Applied rewrites40.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6441.0
Applied rewrites41.0%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
distribute-rgt-inN/A
*-lft-identityN/A
lower-fma.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites64.6%
Taylor expanded in b around inf
Applied rewrites57.2%
Final simplification58.6%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (/ x (+ 1.0 a)))) (if (<= t -6e-78) t_1 (if (<= t 1.85e-75) (/ z b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (1.0 + a);
double tmp;
if (t <= -6e-78) {
tmp = t_1;
} else if (t <= 1.85e-75) {
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 / (1.0d0 + a)
if (t <= (-6d-78)) then
tmp = t_1
else if (t <= 1.85d-75) 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 / (1.0 + a);
double tmp;
if (t <= -6e-78) {
tmp = t_1;
} else if (t <= 1.85e-75) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x / (1.0 + a) tmp = 0 if t <= -6e-78: tmp = t_1 elif t <= 1.85e-75: tmp = z / b else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t <= -6e-78) tmp = t_1; elseif (t <= 1.85e-75) 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 / (1.0 + a); tmp = 0.0; if (t <= -6e-78) tmp = t_1; elseif (t <= 1.85e-75) 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[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6e-78], t$95$1, If[LessEqual[t, 1.85e-75], N[(z / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{1 + a}\\
\mathbf{if}\;t \leq -6 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.85 \cdot 10^{-75}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -5.99999999999999975e-78 or 1.85000000000000012e-75 < t Initial program 80.6%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6456.5
Applied rewrites56.5%
if -5.99999999999999975e-78 < t < 1.85000000000000012e-75Initial program 57.2%
Taylor expanded in t around 0
lower-/.f6456.8
Applied rewrites56.8%
Final simplification56.6%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (fma (- x) a x))) (if (<= t -5.2e+182) t_1 (if (<= t 1.9e+78) (/ z b) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = fma(-x, a, x);
double tmp;
if (t <= -5.2e+182) {
tmp = t_1;
} else if (t <= 1.9e+78) {
tmp = z / b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = fma(Float64(-x), a, x) tmp = 0.0 if (t <= -5.2e+182) tmp = t_1; elseif (t <= 1.9e+78) 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) * a + x), $MachinePrecision]}, If[LessEqual[t, -5.2e+182], t$95$1, If[LessEqual[t, 1.9e+78], N[(z / b), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, x\right)\\
\mathbf{if}\;t \leq -5.2 \cdot 10^{+182}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.9 \cdot 10^{+78}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -5.2e182 or 1.9e78 < t Initial program 79.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6487.0
Applied rewrites87.0%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6472.1
Applied rewrites72.1%
Taylor expanded in a around 0
Applied rewrites42.2%
if -5.2e182 < t < 1.9e78Initial program 67.9%
Taylor expanded in t around 0
lower-/.f6443.0
Applied rewrites43.0%
(FPCore (x y z t a b) :precision binary64 (fma (- x) a x))
double code(double x, double y, double z, double t, double a, double b) {
return fma(-x, a, x);
}
function code(x, y, z, t, a, b) return fma(Float64(-x), a, x) end
code[x_, y_, z_, t_, a_, b_] := N[((-x) * a + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(-x, a, x\right)
\end{array}
Initial program 71.4%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6473.9
Applied rewrites73.9%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6441.1
Applied rewrites41.1%
Taylor expanded in a around 0
Applied rewrites19.9%
(FPCore (x y z t a b) :precision binary64 (* (- a) x))
double code(double x, double y, double z, double t, double a, double b) {
return -a * 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 = -a * x
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return -a * x;
}
def code(x, y, z, t, a, b): return -a * x
function code(x, y, z, t, a, b) return Float64(Float64(-a) * x) end
function tmp = code(x, y, z, t, a, b) tmp = -a * x; end
code[x_, y_, z_, t_, a_, b_] := N[((-a) * x), $MachinePrecision]
\begin{array}{l}
\\
\left(-a\right) \cdot x
\end{array}
Initial program 71.4%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6473.9
Applied rewrites73.9%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6441.1
Applied rewrites41.1%
Taylor expanded in a around 0
Applied rewrites19.9%
Taylor expanded in a around inf
Applied rewrites3.3%
(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 2024268
(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))))