
(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 24 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 (+ (/ (* b y) t) (+ 1.0 a)))
(t_2 (fma (/ b t) y a))
(t_3 (/ (+ (/ (* z y) t) x) t_1))
(t_4 (/ (fma z (/ y t) x) t_1)))
(if (<= t_3 -5e-317)
t_4
(if (<= t_3 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_3 2e+306)
t_4
(if (<= t_3 INFINITY)
(* (+ (/ x (fma z t_2 z)) (/ y (fma t_2 t t))) z)
(/ 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((b / t), y, a);
double t_3 = (((z * y) / t) + x) / t_1;
double t_4 = fma(z, (y / t), x) / t_1;
double tmp;
if (t_3 <= -5e-317) {
tmp = t_4;
} else if (t_3 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_3 <= 2e+306) {
tmp = t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = ((x / fma(z, t_2, z)) + (y / fma(t_2, t, t))) * z;
} else {
tmp = 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 = fma(Float64(b / t), y, a) t_3 = Float64(Float64(Float64(Float64(z * y) / t) + x) / t_1) t_4 = Float64(fma(z, Float64(y / t), x) / t_1) tmp = 0.0 if (t_3 <= -5e-317) tmp = t_4; elseif (t_3 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_3 <= 2e+306) tmp = t_4; elseif (t_3 <= Inf) tmp = Float64(Float64(Float64(x / fma(z, t_2, z)) + Float64(y / fma(t_2, t, t))) * z); else tmp = Float64(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[(b / t), $MachinePrecision] * y + a), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$4 = N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$3, -5e-317], t$95$4, If[LessEqual[t$95$3, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 2e+306], t$95$4, If[LessEqual[t$95$3, Infinity], N[(N[(N[(x / N[(z * t$95$2 + z), $MachinePrecision]), $MachinePrecision] + N[(y / N[(t$95$2 * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[(z / b), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{b \cdot y}{t} + \left(1 + a\right)\\
t_2 := \mathsf{fma}\left(\frac{b}{t}, y, a\right)\\
t_3 := \frac{\frac{z \cdot y}{t} + x}{t\_1}\\
t_4 := \frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{t\_1}\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{-317}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_3 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\left(\frac{x}{\mathsf{fma}\left(z, t\_2, z\right)} + \frac{y}{\mathsf{fma}\left(t\_2, t, t\right)}\right) \cdot z\\
\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))) < -5.00000017e-317 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 95.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.0
Applied rewrites98.0%
if -5.00000017e-317 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 50.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6444.4
Applied rewrites44.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6450.6
Applied rewrites50.6%
Taylor expanded in b around 0
Applied rewrites76.5%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.6%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification95.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* z y) t) x))
(t_2 (/ t_1 (+ (/ (* b y) t) (+ 1.0 a))))
(t_3 (* (/ y (fma (fma (/ b t) y a) t t)) z)))
(if (<= t_2 -1e+233)
t_3
(if (<= t_2 -2e+63)
(/ x (fma b (/ y t) (+ 1.0 a)))
(if (<= t_2 -1e-263)
(/ t_1 (+ 1.0 a))
(if (<= t_2 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_2 2e+306)
(/ (fma (/ y t) z x) (+ 1.0 a))
(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 = ((z * y) / t) + x;
double t_2 = t_1 / (((b * y) / t) + (1.0 + a));
double t_3 = (y / fma(fma((b / t), y, a), t, t)) * z;
double tmp;
if (t_2 <= -1e+233) {
tmp = t_3;
} else if (t_2 <= -2e+63) {
tmp = x / fma(b, (y / t), (1.0 + a));
} else if (t_2 <= -1e-263) {
tmp = t_1 / (1.0 + a);
} else if (t_2 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_2 <= 2e+306) {
tmp = fma((y / t), z, x) / (1.0 + a);
} 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(Float64(Float64(z * y) / t) + x) t_2 = Float64(t_1 / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_3 = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z) tmp = 0.0 if (t_2 <= -1e+233) tmp = t_3; elseif (t_2 <= -2e+63) tmp = Float64(x / fma(b, Float64(y / t), Float64(1.0 + a))); elseif (t_2 <= -1e-263) tmp = Float64(t_1 / Float64(1.0 + a)); elseif (t_2 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_2 <= 2e+306) tmp = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)); 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[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[t$95$2, -1e+233], t$95$3, If[LessEqual[t$95$2, -2e+63], N[(x / N[(b * N[(y / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -1e-263], N[(t$95$1 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+306], N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$3, N[(z / b), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot y}{t} + x\\
t_2 := \frac{t\_1}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_3 := \frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{+233}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq -2 \cdot 10^{+63}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(b, \frac{y}{t}, 1 + a\right)}\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-263}:\\
\;\;\;\;\frac{t\_1}{1 + a}\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\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))) < -9.99999999999999974e232 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 45.2%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites84.4%
if -9.99999999999999974e232 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -2.00000000000000012e63Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.8
Applied rewrites99.8%
Taylor expanded in z around 0
lower-/.f64N/A
+-commutativeN/A
+-commutativeN/A
associate-+l+N/A
associate-/l*N/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f6491.6
Applied rewrites91.6%
if -2.00000000000000012e63 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -1e-263Initial program 98.0%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6468.4
Applied rewrites68.4%
if -1e-263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 54.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6449.4
Applied rewrites49.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6453.4
Applied rewrites53.4%
Taylor expanded in b around 0
Applied rewrites77.0%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6484.2
Applied rewrites84.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6484.3
Applied rewrites84.3%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification82.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* z y) t) x))
(t_2 (/ t_1 (+ (/ (* b y) t) (+ 1.0 a))))
(t_3 (fma (/ y t) z x)))
(if (<= t_2 -2e+63)
(/ t_3 (fma (/ y t) b 1.0))
(if (<= t_2 -1e-263)
(/ t_1 (+ 1.0 a))
(if (<= t_2 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_2 2e+306)
(/ t_3 (+ 1.0 a))
(if (<= t_2 INFINITY)
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(/ z b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((z * y) / t) + x;
double t_2 = t_1 / (((b * y) / t) + (1.0 + a));
double t_3 = fma((y / t), z, x);
double tmp;
if (t_2 <= -2e+63) {
tmp = t_3 / fma((y / t), b, 1.0);
} else if (t_2 <= -1e-263) {
tmp = t_1 / (1.0 + a);
} else if (t_2 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_2 <= 2e+306) {
tmp = t_3 / (1.0 + a);
} else if (t_2 <= ((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(z * y) / t) + x) t_2 = Float64(t_1 / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) t_3 = fma(Float64(y / t), z, x) tmp = 0.0 if (t_2 <= -2e+63) tmp = Float64(t_3 / fma(Float64(y / t), b, 1.0)); elseif (t_2 <= -1e-263) tmp = Float64(t_1 / Float64(1.0 + a)); elseif (t_2 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_2 <= 2e+306) tmp = Float64(t_3 / Float64(1.0 + a)); elseif (t_2 <= Inf) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+63], N[(t$95$3 / N[(N[(y / t), $MachinePrecision] * b + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -1e-263], N[(t$95$1 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+306], N[(t$95$3 / N[(1.0 + a), $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], N[(z / b), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot y}{t} + x\\
t_2 := \frac{t\_1}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
t_3 := \mathsf{fma}\left(\frac{y}{t}, z, x\right)\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+63}:\\
\;\;\;\;\frac{t\_3}{\mathsf{fma}\left(\frac{y}{t}, b, 1\right)}\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-263}:\\
\;\;\;\;\frac{t\_1}{1 + a}\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{t\_3}{1 + a}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\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))) < -2.00000000000000012e63Initial program 81.7%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6469.1
Applied rewrites69.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6479.4
Applied rewrites79.4%
if -2.00000000000000012e63 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -1e-263Initial program 98.0%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6468.4
Applied rewrites68.4%
if -1e-263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 54.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6449.4
Applied rewrites49.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6453.4
Applied rewrites53.4%
Taylor expanded in b around 0
Applied rewrites77.0%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6484.2
Applied rewrites84.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6484.3
Applied rewrites84.3%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.4%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites91.3%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification81.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* z y) t) x)) (t_2 (/ t_1 (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_2 -2e+63)
(/ (fma (/ z t) y x) (fma (/ y t) b 1.0))
(if (<= t_2 -1e-263)
(/ t_1 (+ 1.0 a))
(if (<= t_2 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_2 2e+306)
(/ (fma (/ y t) z x) (+ 1.0 a))
(if (<= t_2 INFINITY)
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(/ z b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = ((z * y) / t) + x;
double t_2 = t_1 / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_2 <= -2e+63) {
tmp = fma((z / t), y, x) / fma((y / t), b, 1.0);
} else if (t_2 <= -1e-263) {
tmp = t_1 / (1.0 + a);
} else if (t_2 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_2 <= 2e+306) {
tmp = fma((y / t), z, x) / (1.0 + a);
} else if (t_2 <= ((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(Float64(z * y) / t) + x) t_2 = Float64(t_1 / Float64(Float64(Float64(b * y) / t) + Float64(1.0 + a))) tmp = 0.0 if (t_2 <= -2e+63) tmp = Float64(fma(Float64(z / t), y, x) / fma(Float64(y / t), b, 1.0)); elseif (t_2 <= -1e-263) tmp = Float64(t_1 / Float64(1.0 + a)); elseif (t_2 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_2 <= 2e+306) tmp = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)); elseif (t_2 <= Inf) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 / N[(N[(N[(b * y), $MachinePrecision] / t), $MachinePrecision] + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -2e+63], N[(N[(N[(z / t), $MachinePrecision] * y + x), $MachinePrecision] / N[(N[(y / t), $MachinePrecision] * b + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -1e-263], N[(t$95$1 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+306], N[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $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], N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot y}{t} + x\\
t_2 := \frac{t\_1}{\frac{b \cdot y}{t} + \left(1 + a\right)}\\
\mathbf{if}\;t\_2 \leq -2 \cdot 10^{+63}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{z}{t}, y, x\right)}{\mathsf{fma}\left(\frac{y}{t}, b, 1\right)}\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-263}:\\
\;\;\;\;\frac{t\_1}{1 + a}\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\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))) < -2.00000000000000012e63Initial program 81.7%
Taylor expanded in a around 0
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6476.9
Applied rewrites76.9%
if -2.00000000000000012e63 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -1e-263Initial program 98.0%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6468.4
Applied rewrites68.4%
if -1e-263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 54.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6449.4
Applied rewrites49.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6453.4
Applied rewrites53.4%
Taylor expanded in b around 0
Applied rewrites77.0%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6484.2
Applied rewrites84.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6484.3
Applied rewrites84.3%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.4%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites91.3%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification80.7%
(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 -2e+263)
(* (/ y (fma a t t)) z)
(if (<= t_1 -2e+63)
(/ x (fma b (/ y t) 1.0))
(if (<= t_1 -1e-263)
(/ (fma (/ z t) y x) a)
(if (<= t_1 0.0)
(/ (* z y) (fma b y t))
(if (<= t_1 2e+306) (/ x (+ 1.0 a)) (/ 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 <= -2e+263) {
tmp = (y / fma(a, t, t)) * z;
} else if (t_1 <= -2e+63) {
tmp = x / fma(b, (y / t), 1.0);
} else if (t_1 <= -1e-263) {
tmp = fma((z / t), y, x) / a;
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, t);
} else if (t_1 <= 2e+306) {
tmp = x / (1.0 + a);
} 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))) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(y / fma(a, t, t)) * z); elseif (t_1 <= -2e+63) tmp = Float64(x / fma(b, Float64(y / t), 1.0)); elseif (t_1 <= -1e-263) tmp = Float64(fma(Float64(z / t), y, x) / a); elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, t)); elseif (t_1 <= 2e+306) tmp = Float64(x / Float64(1.0 + a)); 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]}, If[LessEqual[t$95$1, -2e+263], N[(N[(y / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -2e+63], N[(x / N[(b * N[(y / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -1e-263], N[(N[(N[(z / t), $MachinePrecision] * y + x), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], N[(x / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], 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)}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(a, t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{+63}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(b, \frac{y}{t}, 1\right)}\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{-263}:\\
\;\;\;\;\frac{\mathsf{fma}\left(\frac{z}{t}, y, x\right)}{a}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, t\right)}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{x}{1 + a}\\
\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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites48.2%
Applied rewrites63.3%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -2.00000000000000012e63Initial program 99.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-+.f6483.8
Applied rewrites83.8%
Taylor expanded in a around 0
Applied rewrites72.6%
if -2.00000000000000012e63 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -1e-263Initial program 98.0%
Taylor expanded in a around inf
lower-/.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l/N/A
lower-fma.f64N/A
lower-/.f6448.6
Applied rewrites48.6%
if -1e-263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 54.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6449.4
Applied rewrites49.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6453.4
Applied rewrites53.4%
Taylor expanded in a around 0
Applied rewrites68.5%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6463.6
Applied rewrites63.6%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 10.2%
Taylor expanded in t around 0
lower-/.f6484.2
Applied rewrites84.2%
Final simplification65.4%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (+ 1.0 a)))
(t_2 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a)))))
(if (<= t_2 -5e+168)
(fma y (/ z t) x)
(if (<= t_2 -1e-98)
(* (/ x (fma b y t)) t)
(if (<= t_2 -5e-216)
t_1
(if (<= t_2 0.0) (/ z b) (if (<= t_2 2e+306) t_1 (/ z b))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (1.0 + a);
double t_2 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_2 <= -5e+168) {
tmp = fma(y, (z / t), x);
} else if (t_2 <= -1e-98) {
tmp = (x / fma(b, y, t)) * t;
} else if (t_2 <= -5e-216) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = z / b;
} else if (t_2 <= 2e+306) {
tmp = t_1;
} else {
tmp = z / b;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(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 <= -5e+168) tmp = fma(y, Float64(z / t), x); elseif (t_2 <= -1e-98) tmp = Float64(Float64(x / fma(b, y, t)) * t); elseif (t_2 <= -5e-216) tmp = t_1; elseif (t_2 <= 0.0) tmp = Float64(z / b); elseif (t_2 <= 2e+306) tmp = t_1; else tmp = Float64(z / b); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / 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, -5e+168], N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$2, -1e-98], N[(N[(x / N[(b * y + t), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$2, -5e-216], t$95$1, If[LessEqual[t$95$2, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$2, 2e+306], t$95$1, N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{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 -5 \cdot 10^{+168}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{z}{t}, x\right)\\
\mathbf{elif}\;t\_2 \leq -1 \cdot 10^{-98}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(b, y, t\right)} \cdot t\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{-216}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;t\_1\\
\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))) < -4.99999999999999967e168Initial program 71.9%
lift-+.f64N/A
lift-+.f64N/A
flip-+N/A
lift-/.f64N/A
frac-addN/A
lower-/.f64N/A
lower-fma.f64N/A
metadata-evalN/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f64N/A
lower--.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f6467.1
Applied rewrites67.1%
Taylor expanded in a around 0
mul-1-negN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6449.1
Applied rewrites49.1%
Taylor expanded in b around 0
Applied rewrites49.5%
if -4.99999999999999967e168 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -9.99999999999999939e-99Initial program 99.6%
lift-+.f64N/A
lift-+.f64N/A
flip-+N/A
lift-/.f64N/A
frac-addN/A
lower-/.f64N/A
lower-fma.f64N/A
metadata-evalN/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f64N/A
lower--.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f6469.6
Applied rewrites69.6%
Taylor expanded in a around 0
mul-1-negN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6459.6
Applied rewrites59.6%
Taylor expanded in z around 0
Applied rewrites57.5%
if -9.99999999999999939e-99 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -5.00000000000000021e-216 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6459.2
Applied rewrites59.2%
if -5.00000000000000021e-216 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 36.9%
Taylor expanded in t around 0
lower-/.f6471.7
Applied rewrites71.7%
Final simplification62.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* b y) t) (+ 1.0 a)))
(t_2 (/ (+ (/ (* z y) t) x) t_1))
(t_3 (/ (fma z (/ y t) x) t_1)))
(if (<= t_2 -5e-317)
t_3
(if (<= t_2 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_2 1e+280)
t_3
(if (<= t_2 INFINITY)
(fma
(/ z (fma (fma (/ b t) y a) t t))
y
(/ x (fma (/ b t) y (+ 1.0 a))))
(/ 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 = (((z * y) / t) + x) / t_1;
double t_3 = fma(z, (y / t), x) / t_1;
double tmp;
if (t_2 <= -5e-317) {
tmp = t_3;
} else if (t_2 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_2 <= 1e+280) {
tmp = t_3;
} else if (t_2 <= ((double) INFINITY)) {
tmp = fma((z / fma(fma((b / t), y, a), t, t)), y, (x / fma((b / t), y, (1.0 + a))));
} else {
tmp = 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(Float64(Float64(Float64(z * y) / t) + x) / t_1) t_3 = Float64(fma(z, Float64(y / t), x) / t_1) tmp = 0.0 if (t_2 <= -5e-317) tmp = t_3; elseif (t_2 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_2 <= 1e+280) tmp = t_3; elseif (t_2 <= Inf) tmp = fma(Float64(z / fma(fma(Float64(b / t), y, a), t, t)), y, Float64(x / fma(Float64(b / t), y, Float64(1.0 + a)))); else tmp = Float64(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[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$2, -5e-317], t$95$3, If[LessEqual[t$95$2, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 1e+280], t$95$3, If[LessEqual[t$95$2, Infinity], N[(N[(z / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * y + N[(x / N[(N[(b / t), $MachinePrecision] * y + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{b \cdot y}{t} + \left(1 + a\right)\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{t\_1}\\
t_3 := \frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{t\_1}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{-317}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_2 \leq 10^{+280}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)}, y, \frac{x}{\mathsf{fma}\left(\frac{b}{t}, y, 1 + a\right)}\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))) < -5.00000017e-317 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 1e280Initial program 95.0%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.0
Applied rewrites98.0%
if -5.00000017e-317 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 50.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6444.4
Applied rewrites44.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6450.6
Applied rewrites50.6%
Taylor expanded in b around 0
Applied rewrites76.5%
if 1e280 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 42.2%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites92.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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification94.6%
(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 -1.2e+17)
(/ x 1.0)
(if (<= t_1 -1e-197)
(/ x a)
(if (<= t_1 1e-305)
(/ z b)
(if (<= t_1 2e+135)
(/ x a)
(if (<= t_1 2e+306) (- x (* a x)) (/ 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 <= -1.2e+17) {
tmp = x / 1.0;
} else if (t_1 <= -1e-197) {
tmp = x / a;
} else if (t_1 <= 1e-305) {
tmp = z / b;
} else if (t_1 <= 2e+135) {
tmp = x / a;
} else if (t_1 <= 2e+306) {
tmp = x - (a * x);
} else {
tmp = z / b;
}
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 = (((z * y) / t) + x) / (((b * y) / t) + (1.0d0 + a))
if (t_1 <= (-1.2d+17)) then
tmp = x / 1.0d0
else if (t_1 <= (-1d-197)) then
tmp = x / a
else if (t_1 <= 1d-305) then
tmp = z / b
else if (t_1 <= 2d+135) then
tmp = x / a
else if (t_1 <= 2d+306) then
tmp = x - (a * x)
else
tmp = z / b
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 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double tmp;
if (t_1 <= -1.2e+17) {
tmp = x / 1.0;
} else if (t_1 <= -1e-197) {
tmp = x / a;
} else if (t_1 <= 1e-305) {
tmp = z / b;
} else if (t_1 <= 2e+135) {
tmp = x / a;
} else if (t_1 <= 2e+306) {
tmp = x - (a * x);
} else {
tmp = z / b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)) tmp = 0 if t_1 <= -1.2e+17: tmp = x / 1.0 elif t_1 <= -1e-197: tmp = x / a elif t_1 <= 1e-305: tmp = z / b elif t_1 <= 2e+135: tmp = x / a elif t_1 <= 2e+306: tmp = x - (a * x) 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))) tmp = 0.0 if (t_1 <= -1.2e+17) tmp = Float64(x / 1.0); elseif (t_1 <= -1e-197) tmp = Float64(x / a); elseif (t_1 <= 1e-305) tmp = Float64(z / b); elseif (t_1 <= 2e+135) tmp = Float64(x / a); elseif (t_1 <= 2e+306) tmp = Float64(x - Float64(a * x)); else tmp = Float64(z / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)); tmp = 0.0; if (t_1 <= -1.2e+17) tmp = x / 1.0; elseif (t_1 <= -1e-197) tmp = x / a; elseif (t_1 <= 1e-305) tmp = z / b; elseif (t_1 <= 2e+135) tmp = x / a; elseif (t_1 <= 2e+306) tmp = x - (a * x); else tmp = z / b; end tmp_2 = 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, -1.2e+17], N[(x / 1.0), $MachinePrecision], If[LessEqual[t$95$1, -1e-197], N[(x / a), $MachinePrecision], If[LessEqual[t$95$1, 1e-305], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+135], N[(x / a), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], N[(x - N[(a * x), $MachinePrecision]), $MachinePrecision], 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)}\\
\mathbf{if}\;t\_1 \leq -1.2 \cdot 10^{+17}:\\
\;\;\;\;\frac{x}{1}\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{-197}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t\_1 \leq 10^{-305}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+135}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;x - a \cdot x\\
\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))) < -1.2e17Initial program 85.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6495.7
Applied rewrites95.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6442.2
Applied rewrites42.2%
Taylor expanded in a around 0
Applied rewrites32.9%
if -1.2e17 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -9.9999999999999999e-198 or 9.99999999999999996e-306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 1.99999999999999992e135Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.7
Applied rewrites98.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6453.1
Applied rewrites53.1%
Taylor expanded in a around inf
Applied rewrites38.8%
if -9.9999999999999999e-198 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 9.99999999999999996e-306 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 39.4%
Taylor expanded in t around 0
lower-/.f6469.2
Applied rewrites69.2%
if 1.99999999999999992e135 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.9
Applied rewrites99.9%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6469.0
Applied rewrites69.0%
Taylor expanded in a around 0
Applied rewrites54.9%
Taylor expanded in a around 0
Applied rewrites54.9%
Final simplification50.5%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (- x (* a x))))
(if (<= t_1 -1.2e+17)
t_2
(if (<= t_1 -1e-197)
(/ x a)
(if (<= t_1 1e-305)
(/ z b)
(if (<= t_1 2e+135) (/ x a) (if (<= t_1 2e+306) 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 = x - (a * x);
double tmp;
if (t_1 <= -1.2e+17) {
tmp = t_2;
} else if (t_1 <= -1e-197) {
tmp = x / a;
} else if (t_1 <= 1e-305) {
tmp = z / b;
} else if (t_1 <= 2e+135) {
tmp = x / a;
} else if (t_1 <= 2e+306) {
tmp = t_2;
} else {
tmp = z / b;
}
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) :: t_2
real(8) :: tmp
t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0d0 + a))
t_2 = x - (a * x)
if (t_1 <= (-1.2d+17)) then
tmp = t_2
else if (t_1 <= (-1d-197)) then
tmp = x / a
else if (t_1 <= 1d-305) then
tmp = z / b
else if (t_1 <= 2d+135) then
tmp = x / a
else if (t_1 <= 2d+306) then
tmp = t_2
else
tmp = z / b
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 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = x - (a * x);
double tmp;
if (t_1 <= -1.2e+17) {
tmp = t_2;
} else if (t_1 <= -1e-197) {
tmp = x / a;
} else if (t_1 <= 1e-305) {
tmp = z / b;
} else if (t_1 <= 2e+135) {
tmp = x / a;
} else if (t_1 <= 2e+306) {
tmp = t_2;
} else {
tmp = z / b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)) t_2 = x - (a * x) tmp = 0 if t_1 <= -1.2e+17: tmp = t_2 elif t_1 <= -1e-197: tmp = x / a elif t_1 <= 1e-305: tmp = z / b elif t_1 <= 2e+135: tmp = x / a elif t_1 <= 2e+306: 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 = Float64(x - Float64(a * x)) tmp = 0.0 if (t_1 <= -1.2e+17) tmp = t_2; elseif (t_1 <= -1e-197) tmp = Float64(x / a); elseif (t_1 <= 1e-305) tmp = Float64(z / b); elseif (t_1 <= 2e+135) tmp = Float64(x / a); elseif (t_1 <= 2e+306) tmp = t_2; else tmp = Float64(z / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)); t_2 = x - (a * x); tmp = 0.0; if (t_1 <= -1.2e+17) tmp = t_2; elseif (t_1 <= -1e-197) tmp = x / a; elseif (t_1 <= 1e-305) tmp = z / b; elseif (t_1 <= 2e+135) tmp = x / a; elseif (t_1 <= 2e+306) tmp = t_2; else tmp = z / b; end tmp_2 = 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 - N[(a * x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1.2e+17], t$95$2, If[LessEqual[t$95$1, -1e-197], N[(x / a), $MachinePrecision], If[LessEqual[t$95$1, 1e-305], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+135], N[(x / a), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := x - a \cdot x\\
\mathbf{if}\;t\_1 \leq -1.2 \cdot 10^{+17}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq -1 \cdot 10^{-197}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t\_1 \leq 10^{-305}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+135}:\\
\;\;\;\;\frac{x}{a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -1.2e17 or 1.99999999999999992e135 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 88.8%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6496.7
Applied rewrites96.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6448.8
Applied rewrites48.8%
Taylor expanded in a around 0
Applied rewrites37.3%
Taylor expanded in a around 0
Applied rewrites37.3%
if -1.2e17 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -9.9999999999999999e-198 or 9.99999999999999996e-306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 1.99999999999999992e135Initial program 99.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.7
Applied rewrites98.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6453.1
Applied rewrites53.1%
Taylor expanded in a around inf
Applied rewrites38.8%
if -9.9999999999999999e-198 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 9.99999999999999996e-306 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 39.4%
Taylor expanded in t around 0
lower-/.f6469.2
Applied rewrites69.2%
Final simplification50.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (/ (* b y) t) (+ 1.0 a)))
(t_2 (/ (+ (/ (* z y) t) x) t_1))
(t_3 (/ (fma z (/ y t) x) t_1)))
(if (<= t_2 -5e-317)
t_3
(if (<= t_2 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_2 2e+306)
t_3
(if (<= t_2 INFINITY)
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(/ 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 = (((z * y) / t) + x) / t_1;
double t_3 = fma(z, (y / t), x) / t_1;
double tmp;
if (t_2 <= -5e-317) {
tmp = t_3;
} else if (t_2 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_2 <= 2e+306) {
tmp = t_3;
} else if (t_2 <= ((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} else {
tmp = 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(Float64(Float64(Float64(z * y) / t) + x) / t_1) t_3 = Float64(fma(z, Float64(y / t), x) / t_1) tmp = 0.0 if (t_2 <= -5e-317) tmp = t_3; elseif (t_2 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_2 <= 2e+306) tmp = t_3; elseif (t_2 <= Inf) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); else tmp = Float64(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[(N[(N[(z * y), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision] / t$95$1), $MachinePrecision]}, If[LessEqual[t$95$2, -5e-317], t$95$3, If[LessEqual[t$95$2, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 2e+306], t$95$3, If[LessEqual[t$95$2, Infinity], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], N[(z / b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{b \cdot y}{t} + \left(1 + a\right)\\
t_2 := \frac{\frac{z \cdot y}{t} + x}{t\_1}\\
t_3 := \frac{\mathsf{fma}\left(z, \frac{y}{t}, x\right)}{t\_1}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{-317}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\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))) < -5.00000017e-317 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 95.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.0
Applied rewrites98.0%
if -5.00000017e-317 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 50.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6444.4
Applied rewrites44.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6450.6
Applied rewrites50.6%
Taylor expanded in b around 0
Applied rewrites76.5%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.4%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites91.3%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification94.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 (/ y t) z x) (fma (/ y t) b (+ 1.0 a)))))
(if (<= t_1 -5e-317)
t_2
(if (<= t_1 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_1 2e+306)
t_2
(if (<= t_1 INFINITY)
(* (/ y (fma (fma (/ b t) y a) t t)) z)
(/ 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) / fma((y / t), b, (1.0 + a));
double tmp;
if (t_1 <= -5e-317) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_1 <= 2e+306) {
tmp = t_2;
} else if (t_1 <= ((double) INFINITY)) {
tmp = (y / fma(fma((b / t), y, a), t, t)) * z;
} 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 = Float64(fma(Float64(y / t), z, x) / fma(Float64(y / t), b, Float64(1.0 + a))) tmp = 0.0 if (t_1 <= -5e-317) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_1 <= 2e+306) tmp = t_2; elseif (t_1 <= Inf) tmp = Float64(Float64(y / fma(fma(Float64(b / t), y, a), t, t)) * z); 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[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(N[(y / t), $MachinePrecision] * b + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e-317], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], t$95$2, If[LessEqual[t$95$1, Infinity], N[(N[(y / N[(N[(N[(b / t), $MachinePrecision] * y + a), $MachinePrecision] * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], 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 := \frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{\mathsf{fma}\left(\frac{y}{t}, b, 1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-317}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(\mathsf{fma}\left(\frac{b}{t}, y, a\right), t, t\right)} \cdot z\\
\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))) < -5.00000017e-317 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 95.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6498.0
Applied rewrites98.0%
lift-fma.f64N/A
*-commutativeN/A
lower-fma.f6498.0
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6497.4
lift-+.f64N/A
+-commutativeN/A
lower-+.f6497.4
Applied rewrites97.4%
if -5.00000017e-317 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 50.6%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6444.4
Applied rewrites44.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6450.6
Applied rewrites50.6%
Taylor expanded in b around 0
Applied rewrites76.5%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < +inf.0Initial program 37.4%
Taylor expanded in z around inf
associate-*l/N/A
lower-*.f64N/A
Applied rewrites91.3%
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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification94.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (/ x (fma (/ b t) y (+ 1.0 a)))))
(if (<= t_1 -2e+263)
(* (/ y (fma a t t)) z)
(if (<= t_1 -2e-79)
t_2
(if (<= t_1 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_1 2e+306) 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 = x / fma((b / t), y, (1.0 + a));
double tmp;
if (t_1 <= -2e+263) {
tmp = (y / fma(a, t, t)) * z;
} else if (t_1 <= -2e-79) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_1 <= 2e+306) {
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 = Float64(x / fma(Float64(b / t), y, Float64(1.0 + a))) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(y / fma(a, t, t)) * z); elseif (t_1 <= -2e-79) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_1 <= 2e+306) 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 / N[(N[(b / t), $MachinePrecision] * y + N[(1.0 + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+263], N[(N[(y / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -2e-79], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := \frac{x}{\mathsf{fma}\left(\frac{b}{t}, y, 1 + a\right)}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(a, t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{-79}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites48.2%
Applied rewrites63.3%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -2e-79 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
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-+.f6471.4
Applied rewrites71.4%
if -2e-79 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 74.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6471.4
Applied rewrites71.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6447.3
Applied rewrites47.3%
Taylor expanded in b around 0
Applied rewrites61.1%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 10.2%
Taylor expanded in t around 0
lower-/.f6484.2
Applied rewrites84.2%
Final simplification69.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 -2e+263)
(* (/ y (fma a t t)) z)
(if (<= t_1 -2e-79)
(/ x (fma b (/ y t) 1.0))
(if (<= t_1 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_1 2e+306) (/ x (+ 1.0 a)) (/ 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 <= -2e+263) {
tmp = (y / fma(a, t, t)) * z;
} else if (t_1 <= -2e-79) {
tmp = x / fma(b, (y / t), 1.0);
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_1 <= 2e+306) {
tmp = x / (1.0 + a);
} 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))) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(y / fma(a, t, t)) * z); elseif (t_1 <= -2e-79) tmp = Float64(x / fma(b, Float64(y / t), 1.0)); elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_1 <= 2e+306) tmp = Float64(x / Float64(1.0 + a)); 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]}, If[LessEqual[t$95$1, -2e+263], N[(N[(y / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -2e-79], N[(x / N[(b * N[(y / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], N[(x / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], 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)}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(a, t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{-79}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(b, \frac{y}{t}, 1\right)}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{x}{1 + a}\\
\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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites48.2%
Applied rewrites63.3%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -2e-79Initial program 99.7%
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-+.f6477.6
Applied rewrites77.6%
Taylor expanded in a around 0
Applied rewrites58.5%
if -2e-79 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 74.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6471.4
Applied rewrites71.4%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6447.3
Applied rewrites47.3%
Taylor expanded in b around 0
Applied rewrites61.1%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6463.6
Applied rewrites63.6%
if 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 10.2%
Taylor expanded in t around 0
lower-/.f6484.2
Applied rewrites84.2%
Final simplification65.5%
(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 -2e+263)
(* (/ y (fma a t t)) z)
(if (<= t_1 -5e-259)
(/ x (fma b (/ y t) 1.0))
(if (<= t_1 0.0)
(/ z b)
(if (<= t_1 2e+306) (/ x (+ 1.0 a)) (/ 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 <= -2e+263) {
tmp = (y / fma(a, t, t)) * z;
} else if (t_1 <= -5e-259) {
tmp = x / fma(b, (y / t), 1.0);
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
tmp = x / (1.0 + a);
} 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))) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(y / fma(a, t, t)) * z); elseif (t_1 <= -5e-259) tmp = Float64(x / fma(b, Float64(y / t), 1.0)); elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 2e+306) tmp = Float64(x / Float64(1.0 + a)); 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]}, If[LessEqual[t$95$1, -2e+263], N[(N[(y / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -5e-259], N[(x / N[(b * N[(y / t), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], N[(x / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], 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)}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(a, t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-259}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(b, \frac{y}{t}, 1\right)}\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;\frac{x}{1 + a}\\
\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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites48.2%
Applied rewrites63.3%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -4.99999999999999977e-259Initial program 99.7%
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-+.f6461.4
Applied rewrites61.4%
Taylor expanded in a around 0
Applied rewrites46.3%
if -4.99999999999999977e-259 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 32.7%
Taylor expanded in t around 0
lower-/.f6475.1
Applied rewrites75.1%
if 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6463.6
Applied rewrites63.6%
Final simplification62.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (/ x (+ 1.0 a))))
(if (<= t_1 -2e+263)
(* (/ y (fma a t t)) z)
(if (<= t_1 -5e-216)
t_2
(if (<= t_1 0.0) (/ z b) (if (<= t_1 2e+306) 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 = x / (1.0 + a);
double tmp;
if (t_1 <= -2e+263) {
tmp = (y / fma(a, t, t)) * z;
} else if (t_1 <= -5e-216) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
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 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(y / fma(a, t, t)) * z); elseif (t_1 <= -5e-216) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 2e+306) 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 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+263], N[(N[(y / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t$95$1, -5e-216], t$95$2, If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := \frac{x}{1 + a}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(a, t, t\right)} \cdot z\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites48.2%
Applied rewrites63.3%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -5.00000000000000021e-216 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6455.2
Applied rewrites55.2%
if -5.00000000000000021e-216 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 36.9%
Taylor expanded in t around 0
lower-/.f6471.7
Applied rewrites71.7%
Final simplification61.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (+ (/ (* z y) t) x) (+ (/ (* b y) t) (+ 1.0 a))))
(t_2 (/ x (+ 1.0 a))))
(if (<= t_1 -2e+263)
(* (/ z (fma a t t)) y)
(if (<= t_1 -5e-216)
t_2
(if (<= t_1 0.0) (/ z b) (if (<= t_1 2e+306) 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 = x / (1.0 + a);
double tmp;
if (t_1 <= -2e+263) {
tmp = (z / fma(a, t, t)) * y;
} else if (t_1 <= -5e-216) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
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 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -2e+263) tmp = Float64(Float64(z / fma(a, t, t)) * y); elseif (t_1 <= -5e-216) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 2e+306) 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 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+263], N[(N[(z / N[(a * t + t), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t$95$1, -5e-216], t$95$2, If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := \frac{x}{1 + a}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\frac{z}{\mathsf{fma}\left(a, t, t\right)} \cdot y\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6485.2
Applied rewrites85.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6440.2
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites56.0%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -5.00000000000000021e-216 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6455.2
Applied rewrites55.2%
if -5.00000000000000021e-216 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 36.9%
Taylor expanded in t around 0
lower-/.f6471.7
Applied rewrites71.7%
Final simplification61.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 (/ x (+ 1.0 a))))
(if (<= t_1 -2e+263)
(fma y (/ z t) x)
(if (<= t_1 -5e-216)
t_2
(if (<= t_1 0.0) (/ z b) (if (<= t_1 2e+306) 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 = x / (1.0 + a);
double tmp;
if (t_1 <= -2e+263) {
tmp = fma(y, (z / t), x);
} else if (t_1 <= -5e-216) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
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 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -2e+263) tmp = fma(y, Float64(z / t), x); elseif (t_1 <= -5e-216) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 2e+306) 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 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+263], N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, -5e-216], t$95$2, If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := \frac{x}{1 + a}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+263}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{z}{t}, x\right)\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{-216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -2.00000000000000003e263Initial program 48.3%
lift-+.f64N/A
lift-+.f64N/A
flip-+N/A
lift-/.f64N/A
frac-addN/A
lower-/.f64N/A
lower-fma.f64N/A
metadata-evalN/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
lower-*.f64N/A
lower--.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f6439.8
Applied rewrites39.8%
Taylor expanded in a around 0
mul-1-negN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
distribute-lft-outN/A
mul-1-negN/A
lower-neg.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6448.8
Applied rewrites48.8%
Taylor expanded in b around 0
Applied rewrites48.6%
if -2.00000000000000003e263 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < -5.00000000000000021e-216 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 99.7%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6455.2
Applied rewrites55.2%
if -5.00000000000000021e-216 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 36.9%
Taylor expanded in t around 0
lower-/.f6471.7
Applied rewrites71.7%
Final simplification61.0%
(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 -1e-269)
t_2
(if (<= t_1 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_1 INFINITY) 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((y / t), z, x) / (1.0 + a);
double tmp;
if (t_1 <= -1e-269) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_1 <= ((double) INFINITY)) {
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 = Float64(fma(Float64(y / t), z, x) / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -1e-269) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_1 <= Inf) 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[(N[(N[(y / t), $MachinePrecision] * z + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-269], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], 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 := \frac{\mathsf{fma}\left(\frac{y}{t}, z, x\right)}{1 + a}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-269}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;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))) < -9.9999999999999996e-270 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 91.4%
Taylor expanded in b around 0
+-commutativeN/A
lower-+.f6471.1
Applied rewrites71.1%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
associate-*l/N/A
lift-/.f64N/A
lower-fma.f6472.7
Applied rewrites72.7%
if -9.9999999999999996e-270 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 53.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6448.2
Applied rewrites48.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6452.4
Applied rewrites52.4%
Taylor expanded in b around 0
Applied rewrites76.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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification76.7%
(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 (/ z t) y x) (+ 1.0 a))))
(if (<= t_1 -1e-269)
t_2
(if (<= t_1 0.0)
(/ (* z y) (fma b y (fma a t t)))
(if (<= t_1 INFINITY) 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((z / t), y, x) / (1.0 + a);
double tmp;
if (t_1 <= -1e-269) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = (z * y) / fma(b, y, fma(a, t, t));
} else if (t_1 <= ((double) INFINITY)) {
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 = Float64(fma(Float64(z / t), y, x) / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -1e-269) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))); elseif (t_1 <= Inf) 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[(N[(N[(z / t), $MachinePrecision] * y + x), $MachinePrecision] / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e-269], t$95$2, If[LessEqual[t$95$1, 0.0], N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], 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 := \frac{\mathsf{fma}\left(\frac{z}{t}, y, x\right)}{1 + a}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{-269}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;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))) < -9.9999999999999996e-270 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 91.4%
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.6
Applied rewrites68.6%
if -9.9999999999999996e-270 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0Initial program 53.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6448.2
Applied rewrites48.2%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6452.4
Applied rewrites52.4%
Taylor expanded in b around 0
Applied rewrites76.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 t around 0
lower-/.f64100.0
Applied rewrites100.0%
Final simplification73.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 (/ x (+ 1.0 a))))
(if (<= t_1 -5e-216)
t_2
(if (<= t_1 0.0) (/ z b) (if (<= t_1 2e+306) 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 = x / (1.0 + a);
double tmp;
if (t_1 <= -5e-216) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
tmp = t_2;
} else {
tmp = z / b;
}
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) :: t_2
real(8) :: tmp
t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0d0 + a))
t_2 = x / (1.0d0 + a)
if (t_1 <= (-5d-216)) then
tmp = t_2
else if (t_1 <= 0.0d0) then
tmp = z / b
else if (t_1 <= 2d+306) then
tmp = t_2
else
tmp = z / b
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 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a));
double t_2 = x / (1.0 + a);
double tmp;
if (t_1 <= -5e-216) {
tmp = t_2;
} else if (t_1 <= 0.0) {
tmp = z / b;
} else if (t_1 <= 2e+306) {
tmp = t_2;
} else {
tmp = z / b;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)) t_2 = x / (1.0 + a) tmp = 0 if t_1 <= -5e-216: tmp = t_2 elif t_1 <= 0.0: tmp = z / b elif t_1 <= 2e+306: 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 = Float64(x / Float64(1.0 + a)) tmp = 0.0 if (t_1 <= -5e-216) tmp = t_2; elseif (t_1 <= 0.0) tmp = Float64(z / b); elseif (t_1 <= 2e+306) tmp = t_2; else tmp = Float64(z / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (((z * y) / t) + x) / (((b * y) / t) + (1.0 + a)); t_2 = x / (1.0 + a); tmp = 0.0; if (t_1 <= -5e-216) tmp = t_2; elseif (t_1 <= 0.0) tmp = z / b; elseif (t_1 <= 2e+306) tmp = t_2; else tmp = z / b; end tmp_2 = 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 / N[(1.0 + a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e-216], t$95$2, If[LessEqual[t$95$1, 0.0], N[(z / b), $MachinePrecision], If[LessEqual[t$95$1, 2e+306], 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 := \frac{x}{1 + a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{-216}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 0:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+306}:\\
\;\;\;\;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))) < -5.00000000000000021e-216 or 0.0 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 2.00000000000000003e306Initial program 95.5%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6451.5
Applied rewrites51.5%
if -5.00000000000000021e-216 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) < 0.0 or 2.00000000000000003e306 < (/.f64 (+.f64 x (/.f64 (*.f64 y z) t)) (+.f64 (+.f64 a #s(literal 1 binary64)) (/.f64 (*.f64 y b) t))) Initial program 36.9%
Taylor expanded in t around 0
lower-/.f6471.7
Applied rewrites71.7%
Final simplification59.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* z y) (fma b y (fma a t t))))
(t_2 (/ (+ (/ (* t x) y) z) b)))
(if (<= y -9.5e+38)
t_2
(if (<= y -7.4e-106)
t_1
(if (<= y 3.1e-151) (/ x (+ 1.0 a)) (if (<= y 3.8e-31) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (z * y) / fma(b, y, fma(a, t, t));
double t_2 = (((t * x) / y) + z) / b;
double tmp;
if (y <= -9.5e+38) {
tmp = t_2;
} else if (y <= -7.4e-106) {
tmp = t_1;
} else if (y <= 3.1e-151) {
tmp = x / (1.0 + a);
} else if (y <= 3.8e-31) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(z * y) / fma(b, y, fma(a, t, t))) t_2 = Float64(Float64(Float64(Float64(t * x) / y) + z) / b) tmp = 0.0 if (y <= -9.5e+38) tmp = t_2; elseif (y <= -7.4e-106) tmp = t_1; elseif (y <= 3.1e-151) tmp = Float64(x / Float64(1.0 + a)); elseif (y <= 3.8e-31) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(z * y), $MachinePrecision] / N[(b * y + N[(a * t + t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(t * x), $MachinePrecision] / y), $MachinePrecision] + z), $MachinePrecision] / b), $MachinePrecision]}, If[LessEqual[y, -9.5e+38], t$95$2, If[LessEqual[y, -7.4e-106], t$95$1, If[LessEqual[y, 3.1e-151], N[(x / N[(1.0 + a), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e-31], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z \cdot y}{\mathsf{fma}\left(b, y, \mathsf{fma}\left(a, t, t\right)\right)}\\
t_2 := \frac{\frac{t \cdot x}{y} + z}{b}\\
\mathbf{if}\;y \leq -9.5 \cdot 10^{+38}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -7.4 \cdot 10^{-106}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.1 \cdot 10^{-151}:\\
\;\;\;\;\frac{x}{1 + a}\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{-31}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -9.4999999999999995e38 or 3.8e-31 < y Initial program 49.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6452.1
Applied rewrites52.1%
Taylor expanded in y around -inf
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-/.f64N/A
Applied rewrites49.9%
Taylor expanded in b around inf
Applied rewrites65.9%
if -9.4999999999999995e38 < y < -7.39999999999999959e-106 or 3.09999999999999984e-151 < y < 3.8e-31Initial program 86.2%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6488.0
Applied rewrites88.0%
Taylor expanded in z around inf
lower-/.f64N/A
*-commutativeN/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-/.f6455.9
Applied rewrites55.9%
Taylor expanded in b around 0
Applied rewrites61.6%
if -7.39999999999999959e-106 < y < 3.09999999999999984e-151Initial program 99.8%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6477.8
Applied rewrites77.8%
Final simplification68.2%
(FPCore (x y z t a b) :precision binary64 (if (<= y -1.1e-135) (/ z b) (if (<= y 1e-114) (- x (* a x)) (/ z b))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -1.1e-135) {
tmp = z / b;
} else if (y <= 1e-114) {
tmp = x - (a * x);
} else {
tmp = z / b;
}
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 (y <= (-1.1d-135)) then
tmp = z / b
else if (y <= 1d-114) then
tmp = x - (a * x)
else
tmp = z / b
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 (y <= -1.1e-135) {
tmp = z / b;
} else if (y <= 1e-114) {
tmp = x - (a * x);
} else {
tmp = z / b;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -1.1e-135: tmp = z / b elif y <= 1e-114: tmp = x - (a * x) else: tmp = z / b return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -1.1e-135) tmp = Float64(z / b); elseif (y <= 1e-114) tmp = Float64(x - Float64(a * x)); else tmp = Float64(z / b); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -1.1e-135) tmp = z / b; elseif (y <= 1e-114) tmp = x - (a * x); else tmp = z / b; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -1.1e-135], N[(z / b), $MachinePrecision], If[LessEqual[y, 1e-114], N[(x - N[(a * x), $MachinePrecision]), $MachinePrecision], N[(z / b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.1 \cdot 10^{-135}:\\
\;\;\;\;\frac{z}{b}\\
\mathbf{elif}\;y \leq 10^{-114}:\\
\;\;\;\;x - a \cdot x\\
\mathbf{else}:\\
\;\;\;\;\frac{z}{b}\\
\end{array}
\end{array}
if y < -1.1e-135 or 1.0000000000000001e-114 < y Initial program 61.6%
Taylor expanded in t around 0
lower-/.f6445.4
Applied rewrites45.4%
if -1.1e-135 < y < 1.0000000000000001e-114Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6499.9
Applied rewrites99.9%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6473.5
Applied rewrites73.5%
Taylor expanded in a around 0
Applied rewrites35.6%
Taylor expanded in a around 0
Applied rewrites35.6%
(FPCore (x y z t a b) :precision binary64 (- x (* a x)))
double code(double x, double y, double z, double t, double a, double b) {
return x - (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 = x - (a * x)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x - (a * x);
}
def code(x, y, z, t, a, b): return x - (a * x)
function code(x, y, z, t, a, b) return Float64(x - Float64(a * x)) end
function tmp = code(x, y, z, t, a, b) tmp = x - (a * x); end
code[x_, y_, z_, t_, a_, b_] := N[(x - N[(a * x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - a \cdot x
\end{array}
Initial program 73.5%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6475.3
Applied rewrites75.3%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6440.1
Applied rewrites40.1%
Taylor expanded in a around 0
Applied rewrites17.2%
Taylor expanded in a around 0
Applied rewrites17.2%
(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 73.5%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6475.3
Applied rewrites75.3%
Taylor expanded in t around inf
lower-/.f64N/A
+-commutativeN/A
lower-+.f6440.1
Applied rewrites40.1%
Taylor expanded in a around 0
Applied rewrites17.2%
Taylor expanded in a around inf
Applied rewrites3.8%
(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 2024263
(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))))