
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 28 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x))
(t_2 (fma (fma (- y) j (* b a)) i (fma (fma (- b) z (* j t)) c t_1))))
(if (<= x -5.8e-26)
t_2
(if (<= x 2.75e-132)
(fma
(fma (- x) a (* j c))
t
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)))
(if (<= x 4.2e+88) t_2 t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double t_2 = fma(fma(-y, j, (b * a)), i, fma(fma(-b, z, (j * t)), c, t_1));
double tmp;
if (x <= -5.8e-26) {
tmp = t_2;
} else if (x <= 2.75e-132) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)));
} else if (x <= 4.2e+88) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) t_2 = fma(fma(Float64(-y), j, Float64(b * a)), i, fma(fma(Float64(-b), z, Float64(j * t)), c, t_1)) tmp = 0.0 if (x <= -5.8e-26) tmp = t_2; elseif (x <= 2.75e-132) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b))); elseif (x <= 4.2e+88) tmp = t_2; else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.8e-26], t$95$2, If[LessEqual[x, 2.75e-132], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e+88], t$95$2, t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
t_2 := \mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(\mathsf{fma}\left(-b, z, j \cdot t\right), c, t\_1\right)\right)\\
\mathbf{if}\;x \leq -5.8 \cdot 10^{-26}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 2.75 \cdot 10^{-132}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\right)\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{+88}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -5.7999999999999996e-26 or 2.75e-132 < x < 4.2e88Initial program 74.8%
Applied rewrites79.3%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6446.3
Applied rewrites46.3%
Taylor expanded in c around 0
Applied rewrites85.4%
if -5.7999999999999996e-26 < x < 2.75e-132Initial program 79.2%
Taylor expanded in t around 0
Applied rewrites91.0%
if 4.2e88 < x Initial program 71.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.9
Applied rewrites80.9%
Final simplification86.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b))))
(if (<= (- (* (- (* c t) (* i y)) j) t_1) INFINITY)
(- (/ j (/ 1.0 (fma (- y) i (* c t)))) t_1)
(* (fma (- x) t (* i b)) a))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b);
double tmp;
if (((((c * t) - (i * y)) * j) - t_1) <= ((double) INFINITY)) {
tmp = (j / (1.0 / fma(-y, i, (c * t)))) - t_1;
} else {
tmp = fma(-x, t, (i * b)) * a;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b)) tmp = 0.0 if (Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - t_1) <= Inf) tmp = Float64(Float64(j / Float64(1.0 / fma(Float64(-y), i, Float64(c * t)))) - t_1); else tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - t$95$1), $MachinePrecision], Infinity], N[(N[(j / N[(1.0 / N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\\
\mathbf{if}\;\left(c \cdot t - i \cdot y\right) \cdot j - t\_1 \leq \infty:\\
\;\;\;\;\frac{j}{\frac{1}{\mathsf{fma}\left(-y, i, c \cdot t\right)}} - t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 91.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6491.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6491.7
Applied rewrites91.7%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6459.8
Applied rewrites59.8%
Final simplification86.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))))
(if (<= t_1 INFINITY) t_1 (* (fma (- x) t (* i b)) a))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(-x, t, (i * b)) * a;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 91.7%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6459.8
Applied rewrites59.8%
Final simplification86.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b))))
(if (<= y -1.85e-7)
(fma (fma (- x) a (* j c)) t t_1)
(if (<= y 3.6e+170)
(fma
(fma (- y) j (* b a))
i
(fma (fma (- b) c (* y x)) z (* (fma (- a) x (* j c)) t)))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b));
double tmp;
if (y <= -1.85e-7) {
tmp = fma(fma(-x, a, (j * c)), t, t_1);
} else if (y <= 3.6e+170) {
tmp = fma(fma(-y, j, (b * a)), i, fma(fma(-b, c, (y * x)), z, (fma(-a, x, (j * c)) * t)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b)) tmp = 0.0 if (y <= -1.85e-7) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, t_1); elseif (y <= 3.6e+170) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-a), x, Float64(j * c)) * t))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.85e-7], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + t$95$1), $MachinePrecision], If[LessEqual[y, 3.6e+170], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-a) * x + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\\
\mathbf{if}\;y \leq -1.85 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, t\_1\right)\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{+170}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-a, x, j \cdot c\right) \cdot t\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.85000000000000002e-7Initial program 75.6%
Taylor expanded in t around 0
Applied rewrites87.6%
if -1.85000000000000002e-7 < y < 3.6e170Initial program 80.4%
Applied rewrites83.3%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6445.3
Applied rewrites45.3%
Taylor expanded in c around 0
Applied rewrites82.2%
Taylor expanded in t around 0
Applied rewrites81.6%
if 3.6e170 < y Initial program 57.9%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites85.2%
Final simplification83.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))))
(if (<= z -3.4e+51)
t_1
(if (<= z 5.4e+230)
(fma
(fma (- x) a (* j c))
t
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b)))
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
double tmp;
if (z <= -3.4e+51) {
tmp = t_1;
} else if (z <= 5.4e+230) {
tmp = fma(fma(-x, a, (j * c)), t, fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)) tmp = 0.0 if (z <= -3.4e+51) tmp = t_1; elseif (z <= 5.4e+230) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.4e+51], t$95$1, If[LessEqual[z, 5.4e+230], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{if}\;z \leq -3.4 \cdot 10^{+51}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{+230}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.39999999999999984e51 or 5.40000000000000006e230 < z Initial program 67.1%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites77.8%
if -3.39999999999999984e51 < z < 5.40000000000000006e230Initial program 79.9%
Taylor expanded in t around 0
Applied rewrites83.8%
Final simplification82.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j)))
(t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -7.4e+95)
t_2
(if (<= x -1.46e-285)
t_1
(if (<= x 4.5e-50)
(fma (fma (- y) j (* b a)) i (* (* (- c) z) b))
(if (<= x 2.5e+20) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -7.4e+95) {
tmp = t_2;
} else if (x <= -1.46e-285) {
tmp = t_1;
} else if (x <= 4.5e-50) {
tmp = fma(fma(-y, j, (b * a)), i, ((-c * z) * b));
} else if (x <= 2.5e+20) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -7.4e+95) tmp = t_2; elseif (x <= -1.46e-285) tmp = t_1; elseif (x <= 4.5e-50) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(Float64(Float64(-c) * z) * b)); elseif (x <= 2.5e+20) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -7.4e+95], t$95$2, If[LessEqual[x, -1.46e-285], t$95$1, If[LessEqual[x, 4.5e-50], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.5e+20], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -7.4 \cdot 10^{+95}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.46 \cdot 10^{-285}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{-50}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \left(\left(-c\right) \cdot z\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 2.5 \cdot 10^{+20}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -7.4000000000000003e95 or 2.5e20 < x Initial program 74.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.6
Applied rewrites75.6%
if -7.4000000000000003e95 < x < -1.45999999999999992e-285 or 4.49999999999999962e-50 < x < 2.5e20Initial program 73.8%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites74.6%
if -1.45999999999999992e-285 < x < 4.49999999999999962e-50Initial program 82.2%
Applied rewrites82.1%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6449.6
Applied rewrites49.6%
Taylor expanded in c around 0
Applied rewrites79.5%
Taylor expanded in b around inf
Applied rewrites75.8%
Final simplification75.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -7.4e+95)
t_1
(if (<= x -1.75e-285)
(fma (fma (- b) c (* y x)) z (* (fma (- i) y (* c t)) j))
(if (<= x 1.7e+35)
(fma (fma (- j) i (* z x)) y (* (fma (- c) z (* i a)) b))
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -7.4e+95) {
tmp = t_1;
} else if (x <= -1.75e-285) {
tmp = fma(fma(-b, c, (y * x)), z, (fma(-i, y, (c * t)) * j));
} else if (x <= 1.7e+35) {
tmp = fma(fma(-j, i, (z * x)), y, (fma(-c, z, (i * a)) * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -7.4e+95) tmp = t_1; elseif (x <= -1.75e-285) tmp = fma(fma(Float64(-b), c, Float64(y * x)), z, Float64(fma(Float64(-i), y, Float64(c * t)) * j)); elseif (x <= 1.7e+35) tmp = fma(fma(Float64(-j), i, Float64(z * x)), y, Float64(fma(Float64(-c), z, Float64(i * a)) * b)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -7.4e+95], t$95$1, If[LessEqual[x, -1.75e-285], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.7e+35], N[(N[((-j) * i + N[(z * x), $MachinePrecision]), $MachinePrecision] * y + N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -7.4 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.75 \cdot 10^{-285}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\right)\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{+35}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-j, i, z \cdot x\right), y, \mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -7.4000000000000003e95 or 1.7000000000000001e35 < x Initial program 75.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.1
Applied rewrites76.1%
if -7.4000000000000003e95 < x < -1.7500000000000002e-285Initial program 75.9%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites71.8%
if -1.7500000000000002e-285 < x < 1.7000000000000001e35Initial program 77.2%
Taylor expanded in t around 0
sub-negN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
distribute-rgt-inN/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
Applied rewrites76.4%
Final simplification74.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- c) z) b)) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -2.2e+94)
t_2
(if (<= x -4.4e-204)
(+ t_1 (* (- (* c t) (* i y)) j))
(if (<= x 1.1e+35) (fma (fma (- y) j (* b a)) i t_1) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-c * z) * b;
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -2.2e+94) {
tmp = t_2;
} else if (x <= -4.4e-204) {
tmp = t_1 + (((c * t) - (i * y)) * j);
} else if (x <= 1.1e+35) {
tmp = fma(fma(-y, j, (b * a)), i, t_1);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-c) * z) * b) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -2.2e+94) tmp = t_2; elseif (x <= -4.4e-204) tmp = Float64(t_1 + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); elseif (x <= 1.1e+35) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, t_1); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.2e+94], t$95$2, If[LessEqual[x, -4.4e-204], N[(t$95$1 + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.1e+35], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + t$95$1), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-c\right) \cdot z\right) \cdot b\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -2.2 \cdot 10^{+94}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -4.4 \cdot 10^{-204}:\\
\;\;\;\;t\_1 + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{elif}\;x \leq 1.1 \cdot 10^{+35}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.20000000000000012e94 or 1.0999999999999999e35 < x Initial program 75.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.1
Applied rewrites76.1%
if -2.20000000000000012e94 < x < -4.3999999999999997e-204Initial program 75.3%
Taylor expanded in c around inf
associate-*r*N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6457.4
Applied rewrites57.4%
if -4.3999999999999997e-204 < x < 1.0999999999999999e35Initial program 77.3%
Applied rewrites78.3%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6439.9
Applied rewrites39.9%
Taylor expanded in c around 0
Applied rewrites80.5%
Taylor expanded in b around inf
Applied rewrites70.5%
Final simplification69.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -2.4e+94)
t_1
(if (<= x -1.28e-259)
(+ (* (* i b) a) (* (- (* c t) (* i y)) j))
(if (<= x 1.1e+35)
(fma (fma (- y) j (* b a)) i (* (* (- c) z) b))
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -2.4e+94) {
tmp = t_1;
} else if (x <= -1.28e-259) {
tmp = ((i * b) * a) + (((c * t) - (i * y)) * j);
} else if (x <= 1.1e+35) {
tmp = fma(fma(-y, j, (b * a)), i, ((-c * z) * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -2.4e+94) tmp = t_1; elseif (x <= -1.28e-259) tmp = Float64(Float64(Float64(i * b) * a) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); elseif (x <= 1.1e+35) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(Float64(Float64(-c) * z) * b)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.4e+94], t$95$1, If[LessEqual[x, -1.28e-259], N[(N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.1e+35], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -2.4 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.28 \cdot 10^{-259}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{elif}\;x \leq 1.1 \cdot 10^{+35}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \left(\left(-c\right) \cdot z\right) \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.39999999999999983e94 or 1.0999999999999999e35 < x Initial program 75.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.1
Applied rewrites76.1%
if -2.39999999999999983e94 < x < -1.27999999999999998e-259Initial program 76.9%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
lower-*.f6457.5
Applied rewrites57.5%
if -1.27999999999999998e-259 < x < 1.0999999999999999e35Initial program 76.2%
Applied rewrites77.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6440.2
Applied rewrites40.2%
Taylor expanded in c around 0
Applied rewrites79.9%
Taylor expanded in b around inf
Applied rewrites71.7%
Final simplification69.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (- x) t (* i b))) (t_2 (* (fma (- b) c (* y x)) z)))
(if (<= z -3.75e+93)
t_2
(if (<= z 33000000000.0)
(fma t_1 a (* (* j t) c))
(if (<= z 9.2e+97) (fma t_1 a (* (* (- i) y) j)) t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-x, t, (i * b));
double t_2 = fma(-b, c, (y * x)) * z;
double tmp;
if (z <= -3.75e+93) {
tmp = t_2;
} else if (z <= 33000000000.0) {
tmp = fma(t_1, a, ((j * t) * c));
} else if (z <= 9.2e+97) {
tmp = fma(t_1, a, ((-i * y) * j));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(Float64(-x), t, Float64(i * b)) t_2 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.75e+93) tmp = t_2; elseif (z <= 33000000000.0) tmp = fma(t_1, a, Float64(Float64(j * t) * c)); elseif (z <= 9.2e+97) tmp = fma(t_1, a, Float64(Float64(Float64(-i) * y) * j)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.75e+93], t$95$2, If[LessEqual[z, 33000000000.0], N[(t$95$1 * a + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9.2e+97], N[(t$95$1 * a + N[(N[((-i) * y), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, t, i \cdot b\right)\\
t_2 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.75 \cdot 10^{+93}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 33000000000:\\
\;\;\;\;\mathsf{fma}\left(t\_1, a, \left(j \cdot t\right) \cdot c\right)\\
\mathbf{elif}\;z \leq 9.2 \cdot 10^{+97}:\\
\;\;\;\;\mathsf{fma}\left(t\_1, a, \left(\left(-i\right) \cdot y\right) \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -3.7500000000000001e93 or 9.20000000000000022e97 < z Initial program 66.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6467.5
Applied rewrites67.5%
if -3.7500000000000001e93 < z < 3.3e10Initial program 82.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites70.4%
Taylor expanded in c around inf
Applied rewrites63.5%
if 3.3e10 < z < 9.20000000000000022e97Initial program 76.7%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites82.3%
Taylor expanded in c around inf
Applied rewrites53.8%
Taylor expanded in c around 0
Applied rewrites82.4%
Final simplification66.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c t)) j))
(t_2 (fma (fma (- b) c (* y x)) z t_1)))
(if (<= z -4.1e-67)
t_2
(if (<= z 1.1e+98) (fma (fma (- x) t (* i b)) a t_1) t_2))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-i, y, (c * t)) * j;
double t_2 = fma(fma(-b, c, (y * x)), z, t_1);
double tmp;
if (z <= -4.1e-67) {
tmp = t_2;
} else if (z <= 1.1e+98) {
tmp = fma(fma(-x, t, (i * b)), a, t_1);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-i), y, Float64(c * t)) * j) t_2 = fma(fma(Float64(-b), c, Float64(y * x)), z, t_1) tmp = 0.0 if (z <= -4.1e-67) tmp = t_2; elseif (z <= 1.1e+98) tmp = fma(fma(Float64(-x), t, Float64(i * b)), a, t_1); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z + t$95$1), $MachinePrecision]}, If[LessEqual[z, -4.1e-67], t$95$2, If[LessEqual[z, 1.1e+98], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a + t$95$1), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
t_2 := \mathsf{fma}\left(\mathsf{fma}\left(-b, c, y \cdot x\right), z, t\_1\right)\\
\mathbf{if}\;z \leq -4.1 \cdot 10^{-67}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+98}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, t, i \cdot b\right), a, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -4.0999999999999997e-67 or 1.10000000000000004e98 < z Initial program 69.3%
Taylor expanded in a around 0
sub-negN/A
associate-+r+N/A
sub-negN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-out--N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites73.6%
if -4.0999999999999997e-67 < z < 1.10000000000000004e98Initial program 82.4%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites74.7%
Final simplification74.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -5.1e+95)
t_1
(if (<= x 1.1e+35) (fma (fma (- y) j (* b a)) i (* (* (- c) z) b)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -5.1e+95) {
tmp = t_1;
} else if (x <= 1.1e+35) {
tmp = fma(fma(-y, j, (b * a)), i, ((-c * z) * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -5.1e+95) tmp = t_1; elseif (x <= 1.1e+35) tmp = fma(fma(Float64(-y), j, Float64(b * a)), i, Float64(Float64(Float64(-c) * z) * b)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -5.1e+95], t$95$1, If[LessEqual[x, 1.1e+35], N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i + N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -5.1 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.1 \cdot 10^{+35}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y, j, b \cdot a\right), i, \left(\left(-c\right) \cdot z\right) \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -5.10000000000000003e95 or 1.0999999999999999e35 < x Initial program 75.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.1
Applied rewrites76.1%
if -5.10000000000000003e95 < x < 1.0999999999999999e35Initial program 76.5%
Applied rewrites77.8%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6436.6
Applied rewrites36.6%
Taylor expanded in c around 0
Applied rewrites76.8%
Taylor expanded in b around inf
Applied rewrites62.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- t) x) a)))
(if (<= x -1.8e+212)
(* (* y x) z)
(if (<= x -4.3e-63)
t_1
(if (<= x -6.8e-224)
(* (* (- c) z) b)
(if (<= x 2.6e-20)
(* (* i b) a)
(if (<= x 2.1e+31) (* (* (- j) y) i) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-t * x) * a;
double tmp;
if (x <= -1.8e+212) {
tmp = (y * x) * z;
} else if (x <= -4.3e-63) {
tmp = t_1;
} else if (x <= -6.8e-224) {
tmp = (-c * z) * b;
} else if (x <= 2.6e-20) {
tmp = (i * b) * a;
} else if (x <= 2.1e+31) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (-t * x) * a
if (x <= (-1.8d+212)) then
tmp = (y * x) * z
else if (x <= (-4.3d-63)) then
tmp = t_1
else if (x <= (-6.8d-224)) then
tmp = (-c * z) * b
else if (x <= 2.6d-20) then
tmp = (i * b) * a
else if (x <= 2.1d+31) then
tmp = (-j * y) * i
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 c, double i, double j) {
double t_1 = (-t * x) * a;
double tmp;
if (x <= -1.8e+212) {
tmp = (y * x) * z;
} else if (x <= -4.3e-63) {
tmp = t_1;
} else if (x <= -6.8e-224) {
tmp = (-c * z) * b;
} else if (x <= 2.6e-20) {
tmp = (i * b) * a;
} else if (x <= 2.1e+31) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-t * x) * a tmp = 0 if x <= -1.8e+212: tmp = (y * x) * z elif x <= -4.3e-63: tmp = t_1 elif x <= -6.8e-224: tmp = (-c * z) * b elif x <= 2.6e-20: tmp = (i * b) * a elif x <= 2.1e+31: tmp = (-j * y) * i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-t) * x) * a) tmp = 0.0 if (x <= -1.8e+212) tmp = Float64(Float64(y * x) * z); elseif (x <= -4.3e-63) tmp = t_1; elseif (x <= -6.8e-224) tmp = Float64(Float64(Float64(-c) * z) * b); elseif (x <= 2.6e-20) tmp = Float64(Float64(i * b) * a); elseif (x <= 2.1e+31) tmp = Float64(Float64(Float64(-j) * y) * i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-t * x) * a; tmp = 0.0; if (x <= -1.8e+212) tmp = (y * x) * z; elseif (x <= -4.3e-63) tmp = t_1; elseif (x <= -6.8e-224) tmp = (-c * z) * b; elseif (x <= 2.6e-20) tmp = (i * b) * a; elseif (x <= 2.1e+31) tmp = (-j * y) * i; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-t) * x), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[x, -1.8e+212], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, -4.3e-63], t$95$1, If[LessEqual[x, -6.8e-224], N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 2.6e-20], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 2.1e+31], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-t\right) \cdot x\right) \cdot a\\
\mathbf{if}\;x \leq -1.8 \cdot 10^{+212}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;x \leq -4.3 \cdot 10^{-63}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -6.8 \cdot 10^{-224}:\\
\;\;\;\;\left(\left(-c\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;x \leq 2.6 \cdot 10^{-20}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 2.1 \cdot 10^{+31}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.8e212Initial program 75.5%
Applied rewrites85.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6451.1
Applied rewrites51.1%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6466.3
Applied rewrites66.3%
Taylor expanded in c around 0
Applied rewrites61.5%
if -1.8e212 < x < -4.2999999999999999e-63 or 2.09999999999999979e31 < x Initial program 77.2%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites52.4%
Taylor expanded in x around inf
Applied rewrites40.5%
if -4.2999999999999999e-63 < x < -6.79999999999999984e-224Initial program 68.5%
Applied rewrites70.8%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6421.0
Applied rewrites21.0%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6441.1
Applied rewrites41.1%
Taylor expanded in c around inf
Applied rewrites34.3%
if -6.79999999999999984e-224 < x < 2.59999999999999995e-20Initial program 83.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites70.7%
Taylor expanded in b around inf
Applied rewrites41.1%
if 2.59999999999999995e-20 < x < 2.09999999999999979e31Initial program 54.5%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites48.1%
Taylor expanded in y around inf
Applied rewrites45.9%
Final simplification41.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) z (* j t)) c)) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -2.2e+82)
t_2
(if (<= x -5.2e-287)
t_1
(if (<= x 6.5e-161) (* (* i b) a) (if (<= x 2.25e+20) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-b, z, (j * t)) * c;
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -2.2e+82) {
tmp = t_2;
} else if (x <= -5.2e-287) {
tmp = t_1;
} else if (x <= 6.5e-161) {
tmp = (i * b) * a;
} else if (x <= 2.25e+20) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), z, Float64(j * t)) * c) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -2.2e+82) tmp = t_2; elseif (x <= -5.2e-287) tmp = t_1; elseif (x <= 6.5e-161) tmp = Float64(Float64(i * b) * a); elseif (x <= 2.25e+20) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.2e+82], t$95$2, If[LessEqual[x, -5.2e-287], t$95$1, If[LessEqual[x, 6.5e-161], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 2.25e+20], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -2.2 \cdot 10^{+82}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -5.2 \cdot 10^{-287}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 6.5 \cdot 10^{-161}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 2.25 \cdot 10^{+20}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.2000000000000001e82 or 2.25e20 < x Initial program 74.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.9
Applied rewrites74.9%
if -2.2000000000000001e82 < x < -5.1999999999999999e-287 or 6.50000000000000008e-161 < x < 2.25e20Initial program 74.9%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.1
Applied rewrites50.1%
if -5.1999999999999999e-287 < x < 6.50000000000000008e-161Initial program 84.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites81.1%
Taylor expanded in b around inf
Applied rewrites53.1%
Final simplification60.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)) (t_2 (* (fma (- a) t (* z y)) x)))
(if (<= x -2.9e+85)
t_2
(if (<= x -6.2e-224)
t_1
(if (<= x 4.5e-94) (* (* i b) a) (if (<= x 40.0) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-b, c, (y * x)) * z;
double t_2 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -2.9e+85) {
tmp = t_2;
} else if (x <= -6.2e-224) {
tmp = t_1;
} else if (x <= 4.5e-94) {
tmp = (i * b) * a;
} else if (x <= 40.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) t_2 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -2.9e+85) tmp = t_2; elseif (x <= -6.2e-224) tmp = t_1; elseif (x <= 4.5e-94) tmp = Float64(Float64(i * b) * a); elseif (x <= 40.0) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -2.9e+85], t$95$2, If[LessEqual[x, -6.2e-224], t$95$1, If[LessEqual[x, 4.5e-94], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 40.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
t_2 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -2.9 \cdot 10^{+85}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -6.2 \cdot 10^{-224}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{-94}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 40:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -2.89999999999999997e85 or 40 < x Initial program 72.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.9
Applied rewrites71.9%
if -2.89999999999999997e85 < x < -6.20000000000000017e-224 or 4.5000000000000002e-94 < x < 40Initial program 75.8%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6442.0
Applied rewrites42.0%
if -6.20000000000000017e-224 < x < 4.5000000000000002e-94Initial program 82.1%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites75.0%
Taylor expanded in b around inf
Applied rewrites42.7%
Final simplification54.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)))
(if (<= z -3.75e+93)
t_1
(if (<= z 8.2e+80) (fma (fma (- x) t (* i b)) a (* (* j t) c)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-b, c, (y * x)) * z;
double tmp;
if (z <= -3.75e+93) {
tmp = t_1;
} else if (z <= 8.2e+80) {
tmp = fma(fma(-x, t, (i * b)), a, ((j * t) * c));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) tmp = 0.0 if (z <= -3.75e+93) tmp = t_1; elseif (z <= 8.2e+80) tmp = fma(fma(Float64(-x), t, Float64(i * b)), a, Float64(Float64(j * t) * c)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -3.75e+93], t$95$1, If[LessEqual[z, 8.2e+80], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a + N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{if}\;z \leq -3.75 \cdot 10^{+93}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+80}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, t, i \cdot b\right), a, \left(j \cdot t\right) \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.7500000000000001e93 or 8.20000000000000003e80 < z Initial program 67.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6467.5
Applied rewrites67.5%
if -3.7500000000000001e93 < z < 8.20000000000000003e80Initial program 81.1%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites71.1%
Taylor expanded in c around inf
Applied rewrites62.4%
Final simplification64.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -1.6e+94)
t_1
(if (<= x 2e-160)
(* (fma (- c) z (* i a)) b)
(if (<= x 2.25e+20) (* (fma (- j) t (* b z)) (- c)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -1.6e+94) {
tmp = t_1;
} else if (x <= 2e-160) {
tmp = fma(-c, z, (i * a)) * b;
} else if (x <= 2.25e+20) {
tmp = fma(-j, t, (b * z)) * -c;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -1.6e+94) tmp = t_1; elseif (x <= 2e-160) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (x <= 2.25e+20) tmp = Float64(fma(Float64(-j), t, Float64(b * z)) * Float64(-c)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.6e+94], t$95$1, If[LessEqual[x, 2e-160], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 2.25e+20], N[(N[((-j) * t + N[(b * z), $MachinePrecision]), $MachinePrecision] * (-c)), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-160}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;x \leq 2.25 \cdot 10^{+20}:\\
\;\;\;\;\mathsf{fma}\left(-j, t, b \cdot z\right) \cdot \left(-c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.60000000000000007e94 or 2.25e20 < x Initial program 74.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.6
Applied rewrites75.6%
if -1.60000000000000007e94 < x < 2e-160Initial program 78.2%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.2
Applied rewrites52.2%
if 2e-160 < x < 2.25e20Initial program 73.7%
Applied rewrites75.9%
Taylor expanded in c around -inf
associate-*r*N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.1
Applied rewrites58.1%
Final simplification62.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- a) t) x)))
(if (<= t -2.1e+50)
t_1
(if (<= t -3.3e+21)
(* (* (- i) j) y)
(if (<= t -1e-298)
(* (* y x) z)
(if (<= t 3.6e+102) (* (* (- c) b) z) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-a * t) * x;
double tmp;
if (t <= -2.1e+50) {
tmp = t_1;
} else if (t <= -3.3e+21) {
tmp = (-i * j) * y;
} else if (t <= -1e-298) {
tmp = (y * x) * z;
} else if (t <= 3.6e+102) {
tmp = (-c * b) * z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (-a * t) * x
if (t <= (-2.1d+50)) then
tmp = t_1
else if (t <= (-3.3d+21)) then
tmp = (-i * j) * y
else if (t <= (-1d-298)) then
tmp = (y * x) * z
else if (t <= 3.6d+102) then
tmp = (-c * b) * z
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 c, double i, double j) {
double t_1 = (-a * t) * x;
double tmp;
if (t <= -2.1e+50) {
tmp = t_1;
} else if (t <= -3.3e+21) {
tmp = (-i * j) * y;
} else if (t <= -1e-298) {
tmp = (y * x) * z;
} else if (t <= 3.6e+102) {
tmp = (-c * b) * z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-a * t) * x tmp = 0 if t <= -2.1e+50: tmp = t_1 elif t <= -3.3e+21: tmp = (-i * j) * y elif t <= -1e-298: tmp = (y * x) * z elif t <= 3.6e+102: tmp = (-c * b) * z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-a) * t) * x) tmp = 0.0 if (t <= -2.1e+50) tmp = t_1; elseif (t <= -3.3e+21) tmp = Float64(Float64(Float64(-i) * j) * y); elseif (t <= -1e-298) tmp = Float64(Float64(y * x) * z); elseif (t <= 3.6e+102) tmp = Float64(Float64(Float64(-c) * b) * z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-a * t) * x; tmp = 0.0; if (t <= -2.1e+50) tmp = t_1; elseif (t <= -3.3e+21) tmp = (-i * j) * y; elseif (t <= -1e-298) tmp = (y * x) * z; elseif (t <= 3.6e+102) tmp = (-c * b) * z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[t, -2.1e+50], t$95$1, If[LessEqual[t, -3.3e+21], N[(N[((-i) * j), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t, -1e-298], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 3.6e+102], N[(N[((-c) * b), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-a\right) \cdot t\right) \cdot x\\
\mathbf{if}\;t \leq -2.1 \cdot 10^{+50}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -3.3 \cdot 10^{+21}:\\
\;\;\;\;\left(\left(-i\right) \cdot j\right) \cdot y\\
\mathbf{elif}\;t \leq -1 \cdot 10^{-298}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 3.6 \cdot 10^{+102}:\\
\;\;\;\;\left(\left(-c\right) \cdot b\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.1e50 or 3.6000000000000002e102 < t Initial program 65.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.4
Applied rewrites49.4%
Taylor expanded in a around inf
Applied rewrites43.9%
if -2.1e50 < t < -3.3e21Initial program 100.0%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.1
Applied rewrites76.1%
Taylor expanded in x around 0
Applied rewrites63.7%
if -3.3e21 < t < -9.99999999999999912e-299Initial program 81.1%
Applied rewrites87.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6428.7
Applied rewrites28.7%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.2
Applied rewrites52.2%
Taylor expanded in c around 0
Applied rewrites37.9%
if -9.99999999999999912e-299 < t < 3.6000000000000002e102Initial program 82.7%
Applied rewrites83.9%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6433.8
Applied rewrites33.8%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6451.8
Applied rewrites51.8%
Taylor expanded in c around inf
Applied rewrites35.0%
Final simplification40.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* (- t) x) a)))
(if (<= x -1.8e+212)
(* (* y x) z)
(if (<= x -1.6e+94)
t_1
(if (<= x 2.6e-20)
(* (* i b) a)
(if (<= x 2.1e+31) (* (* (- j) y) i) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (-t * x) * a;
double tmp;
if (x <= -1.8e+212) {
tmp = (y * x) * z;
} else if (x <= -1.6e+94) {
tmp = t_1;
} else if (x <= 2.6e-20) {
tmp = (i * b) * a;
} else if (x <= 2.1e+31) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (-t * x) * a
if (x <= (-1.8d+212)) then
tmp = (y * x) * z
else if (x <= (-1.6d+94)) then
tmp = t_1
else if (x <= 2.6d-20) then
tmp = (i * b) * a
else if (x <= 2.1d+31) then
tmp = (-j * y) * i
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 c, double i, double j) {
double t_1 = (-t * x) * a;
double tmp;
if (x <= -1.8e+212) {
tmp = (y * x) * z;
} else if (x <= -1.6e+94) {
tmp = t_1;
} else if (x <= 2.6e-20) {
tmp = (i * b) * a;
} else if (x <= 2.1e+31) {
tmp = (-j * y) * i;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (-t * x) * a tmp = 0 if x <= -1.8e+212: tmp = (y * x) * z elif x <= -1.6e+94: tmp = t_1 elif x <= 2.6e-20: tmp = (i * b) * a elif x <= 2.1e+31: tmp = (-j * y) * i else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(-t) * x) * a) tmp = 0.0 if (x <= -1.8e+212) tmp = Float64(Float64(y * x) * z); elseif (x <= -1.6e+94) tmp = t_1; elseif (x <= 2.6e-20) tmp = Float64(Float64(i * b) * a); elseif (x <= 2.1e+31) tmp = Float64(Float64(Float64(-j) * y) * i); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (-t * x) * a; tmp = 0.0; if (x <= -1.8e+212) tmp = (y * x) * z; elseif (x <= -1.6e+94) tmp = t_1; elseif (x <= 2.6e-20) tmp = (i * b) * a; elseif (x <= 2.1e+31) tmp = (-j * y) * i; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-t) * x), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[x, -1.8e+212], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, -1.6e+94], t$95$1, If[LessEqual[x, 2.6e-20], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[x, 2.1e+31], N[(N[((-j) * y), $MachinePrecision] * i), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-t\right) \cdot x\right) \cdot a\\
\mathbf{if}\;x \leq -1.8 \cdot 10^{+212}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;x \leq -1.6 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.6 \cdot 10^{-20}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;x \leq 2.1 \cdot 10^{+31}:\\
\;\;\;\;\left(\left(-j\right) \cdot y\right) \cdot i\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.8e212Initial program 75.5%
Applied rewrites85.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6451.1
Applied rewrites51.1%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6466.3
Applied rewrites66.3%
Taylor expanded in c around 0
Applied rewrites61.5%
if -1.8e212 < x < -1.60000000000000007e94 or 2.09999999999999979e31 < x Initial program 75.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites48.6%
Taylor expanded in x around inf
Applied rewrites44.5%
if -1.60000000000000007e94 < x < 2.59999999999999995e-20Initial program 78.9%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites66.1%
Taylor expanded in b around inf
Applied rewrites32.1%
if 2.59999999999999995e-20 < x < 2.09999999999999979e31Initial program 54.5%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites48.1%
Taylor expanded in y around inf
Applied rewrites45.9%
Final simplification39.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -1.6e+94)
t_1
(if (<= x 2e-160)
(* (fma (- c) z (* i a)) b)
(if (<= x 2.25e+20) (* (fma (- b) z (* j t)) c) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -1.6e+94) {
tmp = t_1;
} else if (x <= 2e-160) {
tmp = fma(-c, z, (i * a)) * b;
} else if (x <= 2.25e+20) {
tmp = fma(-b, z, (j * t)) * c;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -1.6e+94) tmp = t_1; elseif (x <= 2e-160) tmp = Float64(fma(Float64(-c), z, Float64(i * a)) * b); elseif (x <= 2.25e+20) tmp = Float64(fma(Float64(-b), z, Float64(j * t)) * c); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.6e+94], t$95$1, If[LessEqual[x, 2e-160], N[(N[((-c) * z + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 2.25e+20], N[(N[((-b) * z + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-160}:\\
\;\;\;\;\mathsf{fma}\left(-c, z, i \cdot a\right) \cdot b\\
\mathbf{elif}\;x \leq 2.25 \cdot 10^{+20}:\\
\;\;\;\;\mathsf{fma}\left(-b, z, j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.60000000000000007e94 or 2.25e20 < x Initial program 74.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.6
Applied rewrites75.6%
if -1.60000000000000007e94 < x < 2e-160Initial program 78.2%
Taylor expanded in b around inf
*-commutativeN/A
sub-negN/A
+-commutativeN/A
remove-double-negN/A
distribute-neg-inN/A
sub-negN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
distribute-neg-inN/A
distribute-lft-neg-inN/A
neg-mul-1N/A
remove-double-negN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6452.2
Applied rewrites52.2%
if 2e-160 < x < 2.25e20Initial program 73.7%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6458.1
Applied rewrites58.1%
Final simplification62.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- a) t (* z y)) x)))
(if (<= x -1.05e-97)
t_1
(if (<= x -6.8e-224)
(* (* (- c) z) b)
(if (<= x 2.3e-18) (* (* i b) a) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-a, t, (z * y)) * x;
double tmp;
if (x <= -1.05e-97) {
tmp = t_1;
} else if (x <= -6.8e-224) {
tmp = (-c * z) * b;
} else if (x <= 2.3e-18) {
tmp = (i * b) * a;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-a), t, Float64(z * y)) * x) tmp = 0.0 if (x <= -1.05e-97) tmp = t_1; elseif (x <= -6.8e-224) tmp = Float64(Float64(Float64(-c) * z) * b); elseif (x <= 2.3e-18) tmp = Float64(Float64(i * b) * a); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.05e-97], t$95$1, If[LessEqual[x, -6.8e-224], N[(N[((-c) * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[x, 2.3e-18], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -1.05 \cdot 10^{-97}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -6.8 \cdot 10^{-224}:\\
\;\;\;\;\left(\left(-c\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;x \leq 2.3 \cdot 10^{-18}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.0500000000000001e-97 or 2.3000000000000001e-18 < x Initial program 74.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.3
Applied rewrites62.3%
if -1.0500000000000001e-97 < x < -6.79999999999999984e-224Initial program 70.8%
Applied rewrites73.8%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6423.5
Applied rewrites23.5%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6435.2
Applied rewrites35.2%
Taylor expanded in c around inf
Applied rewrites34.2%
if -6.79999999999999984e-224 < x < 2.3000000000000001e-18Initial program 81.9%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites69.9%
Taylor expanded in b around inf
Applied rewrites40.6%
Final simplification52.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -2.3e+89) (* (* z y) x) (if (<= z 8.4e+79) (* (* (- a) t) x) (* (* y x) z))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.3e+89) {
tmp = (z * y) * x;
} else if (z <= 8.4e+79) {
tmp = (-a * t) * x;
} else {
tmp = (y * x) * z;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-2.3d+89)) then
tmp = (z * y) * x
else if (z <= 8.4d+79) then
tmp = (-a * t) * x
else
tmp = (y * x) * z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.3e+89) {
tmp = (z * y) * x;
} else if (z <= 8.4e+79) {
tmp = (-a * t) * x;
} else {
tmp = (y * x) * z;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.3e+89: tmp = (z * y) * x elif z <= 8.4e+79: tmp = (-a * t) * x else: tmp = (y * x) * z return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.3e+89) tmp = Float64(Float64(z * y) * x); elseif (z <= 8.4e+79) tmp = Float64(Float64(Float64(-a) * t) * x); else tmp = Float64(Float64(y * x) * z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.3e+89) tmp = (z * y) * x; elseif (z <= 8.4e+79) tmp = (-a * t) * x; else tmp = (y * x) * z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.3e+89], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 8.4e+79], N[(N[((-a) * t), $MachinePrecision] * x), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.3 \cdot 10^{+89}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{elif}\;z \leq 8.4 \cdot 10^{+79}:\\
\;\;\;\;\left(\left(-a\right) \cdot t\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if z < -2.2999999999999999e89Initial program 70.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.7
Applied rewrites46.7%
Taylor expanded in a around 0
Applied rewrites38.7%
if -2.2999999999999999e89 < z < 8.40000000000000032e79Initial program 80.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.9
Applied rewrites39.9%
Taylor expanded in a around inf
Applied rewrites34.3%
if 8.40000000000000032e79 < z Initial program 66.5%
Applied rewrites68.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6423.2
Applied rewrites23.2%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6468.5
Applied rewrites68.5%
Taylor expanded in c around 0
Applied rewrites41.3%
Final simplification36.5%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -2.3e+89) (* (* z y) x) (if (<= z 1.05e+79) (* (* (- t) x) a) (* (* y x) z))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.3e+89) {
tmp = (z * y) * x;
} else if (z <= 1.05e+79) {
tmp = (-t * x) * a;
} else {
tmp = (y * x) * z;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-2.3d+89)) then
tmp = (z * y) * x
else if (z <= 1.05d+79) then
tmp = (-t * x) * a
else
tmp = (y * x) * z
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.3e+89) {
tmp = (z * y) * x;
} else if (z <= 1.05e+79) {
tmp = (-t * x) * a;
} else {
tmp = (y * x) * z;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.3e+89: tmp = (z * y) * x elif z <= 1.05e+79: tmp = (-t * x) * a else: tmp = (y * x) * z return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.3e+89) tmp = Float64(Float64(z * y) * x); elseif (z <= 1.05e+79) tmp = Float64(Float64(Float64(-t) * x) * a); else tmp = Float64(Float64(y * x) * z); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.3e+89) tmp = (z * y) * x; elseif (z <= 1.05e+79) tmp = (-t * x) * a; else tmp = (y * x) * z; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.3e+89], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 1.05e+79], N[(N[((-t) * x), $MachinePrecision] * a), $MachinePrecision], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.3 \cdot 10^{+89}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{+79}:\\
\;\;\;\;\left(\left(-t\right) \cdot x\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\end{array}
\end{array}
if z < -2.2999999999999999e89Initial program 70.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.7
Applied rewrites46.7%
Taylor expanded in a around 0
Applied rewrites38.7%
if -2.2999999999999999e89 < z < 1.05000000000000004e79Initial program 80.8%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites71.4%
Taylor expanded in x around inf
Applied rewrites33.1%
if 1.05000000000000004e79 < z Initial program 66.5%
Applied rewrites68.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6423.2
Applied rewrites23.2%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6468.5
Applied rewrites68.5%
Taylor expanded in c around 0
Applied rewrites41.3%
Final simplification35.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= x -4e+102) (* (* y x) z) (if (<= x 5.3e-13) (* (* i b) a) (* (* z y) x))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -4e+102) {
tmp = (y * x) * z;
} else if (x <= 5.3e-13) {
tmp = (i * b) * a;
} else {
tmp = (z * y) * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-4d+102)) then
tmp = (y * x) * z
else if (x <= 5.3d-13) then
tmp = (i * b) * a
else
tmp = (z * y) * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -4e+102) {
tmp = (y * x) * z;
} else if (x <= 5.3e-13) {
tmp = (i * b) * a;
} else {
tmp = (z * y) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -4e+102: tmp = (y * x) * z elif x <= 5.3e-13: tmp = (i * b) * a else: tmp = (z * y) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -4e+102) tmp = Float64(Float64(y * x) * z); elseif (x <= 5.3e-13) tmp = Float64(Float64(i * b) * a); else tmp = Float64(Float64(z * y) * x); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -4e+102) tmp = (y * x) * z; elseif (x <= 5.3e-13) tmp = (i * b) * a; else tmp = (z * y) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -4e+102], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[x, 5.3e-13], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -4 \cdot 10^{+102}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{-13}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\end{array}
\end{array}
if x < -3.99999999999999991e102Initial program 79.2%
Applied rewrites88.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6450.7
Applied rewrites50.7%
Taylor expanded in z around inf
*-commutativeN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-*.f6450.1
Applied rewrites50.1%
Taylor expanded in c around 0
Applied rewrites45.7%
if -3.99999999999999991e102 < x < 5.2999999999999996e-13Initial program 78.8%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites66.4%
Taylor expanded in b around inf
Applied rewrites31.2%
if 5.2999999999999996e-13 < x Initial program 67.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.8
Applied rewrites68.8%
Taylor expanded in a around 0
Applied rewrites36.9%
Final simplification35.2%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* z y) x))) (if (<= x -4e+102) t_1 (if (<= x 5.3e-13) (* (* i b) a) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * y) * x;
double tmp;
if (x <= -4e+102) {
tmp = t_1;
} else if (x <= 5.3e-13) {
tmp = (i * b) * a;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (z * y) * x
if (x <= (-4d+102)) then
tmp = t_1
else if (x <= 5.3d-13) then
tmp = (i * b) * a
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 c, double i, double j) {
double t_1 = (z * y) * x;
double tmp;
if (x <= -4e+102) {
tmp = t_1;
} else if (x <= 5.3e-13) {
tmp = (i * b) * a;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (z * y) * x tmp = 0 if x <= -4e+102: tmp = t_1 elif x <= 5.3e-13: tmp = (i * b) * a else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * y) * x) tmp = 0.0 if (x <= -4e+102) tmp = t_1; elseif (x <= 5.3e-13) tmp = Float64(Float64(i * b) * a); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (z * y) * x; tmp = 0.0; if (x <= -4e+102) tmp = t_1; elseif (x <= 5.3e-13) tmp = (i * b) * a; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -4e+102], t$95$1, If[LessEqual[x, 5.3e-13], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot y\right) \cdot x\\
\mathbf{if}\;x \leq -4 \cdot 10^{+102}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 5.3 \cdot 10^{-13}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.99999999999999991e102 or 5.2999999999999996e-13 < x Initial program 72.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
mul-1-negN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.7
Applied rewrites70.7%
Taylor expanded in a around 0
Applied rewrites38.6%
if -3.99999999999999991e102 < x < 5.2999999999999996e-13Initial program 78.8%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites66.4%
Taylor expanded in b around inf
Applied rewrites31.2%
Final simplification34.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -8.5e-120) (* (* b a) i) (if (<= b 7.6e+86) (* (* j t) c) (* (* i b) a))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -8.5e-120) {
tmp = (b * a) * i;
} else if (b <= 7.6e+86) {
tmp = (j * t) * c;
} else {
tmp = (i * b) * a;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-8.5d-120)) then
tmp = (b * a) * i
else if (b <= 7.6d+86) then
tmp = (j * t) * c
else
tmp = (i * b) * a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -8.5e-120) {
tmp = (b * a) * i;
} else if (b <= 7.6e+86) {
tmp = (j * t) * c;
} else {
tmp = (i * b) * a;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -8.5e-120: tmp = (b * a) * i elif b <= 7.6e+86: tmp = (j * t) * c else: tmp = (i * b) * a return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -8.5e-120) tmp = Float64(Float64(b * a) * i); elseif (b <= 7.6e+86) tmp = Float64(Float64(j * t) * c); else tmp = Float64(Float64(i * b) * a); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -8.5e-120) tmp = (b * a) * i; elseif (b <= 7.6e+86) tmp = (j * t) * c; else tmp = (i * b) * a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.5e-120], N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision], If[LessEqual[b, 7.6e+86], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.5 \cdot 10^{-120}:\\
\;\;\;\;\left(b \cdot a\right) \cdot i\\
\mathbf{elif}\;b \leq 7.6 \cdot 10^{+86}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\end{array}
\end{array}
if b < -8.50000000000000059e-120Initial program 71.2%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites54.1%
Taylor expanded in b around inf
Applied rewrites31.2%
Applied rewrites31.2%
if -8.50000000000000059e-120 < b < 7.59999999999999956e86Initial program 76.6%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites63.2%
Taylor expanded in c around inf
Applied rewrites28.3%
if 7.59999999999999956e86 < b Initial program 82.3%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites51.3%
Taylor expanded in b around inf
Applied rewrites41.5%
Final simplification31.9%
(FPCore (x y z t a b c i j) :precision binary64 (* (* b a) i))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (b * a) * i;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = (b * a) * i
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (b * a) * i;
}
def code(x, y, z, t, a, b, c, i, j): return (b * a) * i
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(b * a) * i) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (b * a) * i; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(b * a), $MachinePrecision] * i), $MachinePrecision]
\begin{array}{l}
\\
\left(b \cdot a\right) \cdot i
\end{array}
Initial program 76.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites58.0%
Taylor expanded in b around inf
Applied rewrites22.5%
Applied rewrites22.5%
(FPCore (x y z t a b c i j) :precision binary64 (* (* i a) b))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (i * a) * b;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = (i * a) * b
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (i * a) * b;
}
def code(x, y, z, t, a, b, c, i, j): return (i * a) * b
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(i * a) * b) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (i * a) * b; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(i * a), $MachinePrecision] * b), $MachinePrecision]
\begin{array}{l}
\\
\left(i \cdot a\right) \cdot b
\end{array}
Initial program 76.0%
Taylor expanded in z around 0
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-lft-identityN/A
metadata-evalN/A
cancel-sign-sub-invN/A
+-commutativeN/A
Applied rewrites58.0%
Taylor expanded in b around inf
Applied rewrites22.5%
Applied rewrites22.1%
Final simplification22.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024235
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1015122364899489/125000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -942510763643697/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (if (< t -238547917063487/3125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 10535888557455487/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))