
(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 29 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 (- (* a i) (* z c))) (t_2 (* j (- (* t c) (* y i)))))
(if (<= (+ (+ (* x (- (* y z) (* t a))) (* b t_1)) t_2) INFINITY)
(- t_2 (+ (/ b (/ -1.0 t_1)) (* x (- (* t a) (* y z)))))
(* z (- (fma y x (/ (* a (* b i)) z)) (* b c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (a * i) - (z * c);
double t_2 = j * ((t * c) - (y * i));
double tmp;
if ((((x * ((y * z) - (t * a))) + (b * t_1)) + t_2) <= ((double) INFINITY)) {
tmp = t_2 - ((b / (-1.0 / t_1)) + (x * ((t * a) - (y * z))));
} else {
tmp = z * (fma(y, x, ((a * (b * i)) / z)) - (b * c));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(a * i) - Float64(z * c)) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * t_1)) + t_2) <= Inf) tmp = Float64(t_2 - Float64(Float64(b / Float64(-1.0 / t_1)) + Float64(x * Float64(Float64(t * a) - Float64(y * z))))); else tmp = Float64(z * Float64(fma(y, x, Float64(Float64(a * Float64(b * i)) / z)) - Float64(b * c))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], Infinity], N[(t$95$2 - N[(N[(b / N[(-1.0 / t$95$1), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(y * x + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot i - z \cdot c\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;\left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot t\_1\right) + t\_2 \leq \infty:\\
\;\;\;\;t\_2 - \left(\frac{b}{\frac{-1}{t\_1}} + x \cdot \left(t \cdot a - y \cdot z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(\mathsf{fma}\left(y, x, \frac{a \cdot \left(b \cdot i\right)}{z}\right) - b \cdot c\right)\\
\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 88.4%
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-/.f6488.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6488.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6488.4
Applied rewrites88.4%
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 z around inf
Applied rewrites51.1%
Taylor expanded in b around inf
Applied rewrites71.5%
Final simplification85.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* z (- (fma y x (/ (* a (* b i)) z)) (* b c))))))
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 * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = z * (fma(y, x, ((a * (b * i)) / z)) - (b * c));
}
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(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(z * Float64(fma(y, x, Float64(Float64(a * Float64(b * i)) / z)) - Float64(b * c))); end return 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[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(z * N[(N[(y * x + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(\mathsf{fma}\left(y, x, \frac{a \cdot \left(b \cdot i\right)}{z}\right) - b \cdot c\right)\\
\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 88.4%
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 z around inf
Applied rewrites51.1%
Taylor expanded in b around inf
Applied rewrites71.5%
Final simplification85.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma b (- c) (* x y))))
(if (<= i -7.4e+83)
(* i (fma j (- y) (* a b)))
(if (<= i -4e-204)
(fma z t_1 (* b (* a i)))
(if (<= i 4.8e-136)
(fma c (fma j t (* z (- b))) (* x (* y z)))
(if (<= i 2.8e+78)
(fma z t_1 (- (* t (* x a))))
(* i (fma b a (* y (- j))))))))))
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, (x * y));
double tmp;
if (i <= -7.4e+83) {
tmp = i * fma(j, -y, (a * b));
} else if (i <= -4e-204) {
tmp = fma(z, t_1, (b * (a * i)));
} else if (i <= 4.8e-136) {
tmp = fma(c, fma(j, t, (z * -b)), (x * (y * z)));
} else if (i <= 2.8e+78) {
tmp = fma(z, t_1, -(t * (x * a)));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(b, Float64(-c), Float64(x * y)) tmp = 0.0 if (i <= -7.4e+83) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); elseif (i <= -4e-204) tmp = fma(z, t_1, Float64(b * Float64(a * i))); elseif (i <= 4.8e-136) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(y * z))); elseif (i <= 2.8e+78) tmp = fma(z, t_1, Float64(-Float64(t * Float64(x * a)))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * (-c) + N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -7.4e+83], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -4e-204], N[(z * t$95$1 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4.8e-136], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.8e+78], N[(z * t$95$1 + (-N[(t * N[(x * a), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(b, -c, x \cdot y\right)\\
\mathbf{if}\;i \leq -7.4 \cdot 10^{+83}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{elif}\;i \leq -4 \cdot 10^{-204}:\\
\;\;\;\;\mathsf{fma}\left(z, t\_1, b \cdot \left(a \cdot i\right)\right)\\
\mathbf{elif}\;i \leq 4.8 \cdot 10^{-136}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z\right)\right)\\
\mathbf{elif}\;i \leq 2.8 \cdot 10^{+78}:\\
\;\;\;\;\mathsf{fma}\left(z, t\_1, -t \cdot \left(x \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -7.4000000000000005e83Initial program 63.0%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6481.7
Applied rewrites81.7%
if -7.4000000000000005e83 < i < -4e-204Initial program 78.6%
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-/.f6478.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.5
Applied rewrites78.5%
Taylor expanded in j around 0
Applied rewrites75.6%
Taylor expanded in t around 0
Applied rewrites71.8%
if -4e-204 < i < 4.7999999999999997e-136Initial program 78.4%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites78.4%
Taylor expanded in y around inf
Applied rewrites69.3%
if 4.7999999999999997e-136 < i < 2.8000000000000001e78Initial program 78.3%
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-/.f6478.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.2
Applied rewrites78.2%
Taylor expanded in j around 0
Applied rewrites78.1%
Taylor expanded in t around inf
Applied rewrites75.7%
if 2.8000000000000001e78 < i Initial program 65.5%
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-/.f6465.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6465.6
lift-*.f64N/A
*-commutativeN/A
lower-*.f6465.6
Applied rewrites65.6%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6475.6
Applied rewrites75.6%
Final simplification74.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma z (fma b (- c) (* x y)) (* b (* a i))))
(t_2 (* i (fma j (- y) (* a b)))))
(if (<= i -7.4e+83)
t_2
(if (<= i -1.35e-166)
t_1
(if (<= i 9.2e-273)
(fma c (fma j t (* z (- b))) (* x (- (* t a))))
(if (<= i 8.6e+154) 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(z, fma(b, -c, (x * y)), (b * (a * i)));
double t_2 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -7.4e+83) {
tmp = t_2;
} else if (i <= -1.35e-166) {
tmp = t_1;
} else if (i <= 9.2e-273) {
tmp = fma(c, fma(j, t, (z * -b)), (x * -(t * a)));
} else if (i <= 8.6e+154) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(z, fma(b, Float64(-c), Float64(x * y)), Float64(b * Float64(a * i))) t_2 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -7.4e+83) tmp = t_2; elseif (i <= -1.35e-166) tmp = t_1; elseif (i <= 9.2e-273) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(-Float64(t * a)))); elseif (i <= 8.6e+154) 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[(z * N[(b * (-c) + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -7.4e+83], t$95$2, If[LessEqual[i, -1.35e-166], t$95$1, If[LessEqual[i, 9.2e-273], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * (-N[(t * a), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 8.6e+154], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(z, \mathsf{fma}\left(b, -c, x \cdot y\right), b \cdot \left(a \cdot i\right)\right)\\
t_2 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -7.4 \cdot 10^{+83}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;i \leq -1.35 \cdot 10^{-166}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 9.2 \cdot 10^{-273}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(-t \cdot a\right)\right)\\
\mathbf{elif}\;i \leq 8.6 \cdot 10^{+154}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if i < -7.4000000000000005e83 or 8.5999999999999995e154 < i Initial program 61.8%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
if -7.4000000000000005e83 < i < -1.35000000000000003e-166 or 9.19999999999999923e-273 < i < 8.5999999999999995e154Initial program 79.3%
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-/.f6479.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6479.3
lift-*.f64N/A
*-commutativeN/A
lower-*.f6479.3
Applied rewrites79.3%
Taylor expanded in j around 0
Applied rewrites72.5%
Taylor expanded in t around 0
Applied rewrites67.2%
if -1.35000000000000003e-166 < i < 9.19999999999999923e-273Initial program 77.3%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites84.1%
Taylor expanded in y around 0
Applied rewrites71.3%
Final simplification72.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma b (- c) (* x y))) (t_2 (fma z t_1 (* b (* a i)))))
(if (<= b -29000000000.0)
t_2
(if (<= b 2.45e-179)
(+ (* j (- (* t c) (* y i))) (* z (* x y)))
(if (<= b 2e-60) (fma z t_1 (- (* t (* x a)))) 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, (x * y));
double t_2 = fma(z, t_1, (b * (a * i)));
double tmp;
if (b <= -29000000000.0) {
tmp = t_2;
} else if (b <= 2.45e-179) {
tmp = (j * ((t * c) - (y * i))) + (z * (x * y));
} else if (b <= 2e-60) {
tmp = fma(z, t_1, -(t * (x * a)));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(b, Float64(-c), Float64(x * y)) t_2 = fma(z, t_1, Float64(b * Float64(a * i))) tmp = 0.0 if (b <= -29000000000.0) tmp = t_2; elseif (b <= 2.45e-179) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(z * Float64(x * y))); elseif (b <= 2e-60) tmp = fma(z, t_1, Float64(-Float64(t * Float64(x * a)))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * (-c) + N[(x * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * t$95$1 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -29000000000.0], t$95$2, If[LessEqual[b, 2.45e-179], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e-60], N[(z * t$95$1 + (-N[(t * N[(x * a), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(b, -c, x \cdot y\right)\\
t_2 := \mathsf{fma}\left(z, t\_1, b \cdot \left(a \cdot i\right)\right)\\
\mathbf{if}\;b \leq -29000000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 2.45 \cdot 10^{-179}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-60}:\\
\;\;\;\;\mathsf{fma}\left(z, t\_1, -t \cdot \left(x \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -2.9e10 or 1.9999999999999999e-60 < b Initial program 74.5%
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-/.f6474.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6474.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6474.5
Applied rewrites74.5%
Taylor expanded in j around 0
Applied rewrites71.0%
Taylor expanded in t around 0
Applied rewrites77.4%
if -2.9e10 < b < 2.45e-179Initial program 70.4%
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-/.f6470.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6470.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6470.4
Applied rewrites70.4%
Taylor expanded in y around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.6
Applied rewrites67.6%
if 2.45e-179 < b < 1.9999999999999999e-60Initial program 72.4%
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-/.f6472.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6472.4
lift-*.f64N/A
*-commutativeN/A
lower-*.f6472.4
Applied rewrites72.4%
Taylor expanded in j around 0
Applied rewrites84.3%
Taylor expanded in t around inf
Applied rewrites72.5%
Final simplification73.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma y (fma j (- i) (* x z)) (* b (fma c (- z) (* a i))))))
(if (<= y -3.8e-71)
t_1
(if (<= y 1.1e+220)
(fma z (fma b (- c) (* x y)) (* a (fma t (- x) (* b 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 = fma(y, fma(j, -i, (x * z)), (b * fma(c, -z, (a * i))));
double tmp;
if (y <= -3.8e-71) {
tmp = t_1;
} else if (y <= 1.1e+220) {
tmp = fma(z, fma(b, -c, (x * y)), (a * fma(t, -x, (b * i))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(y, fma(j, Float64(-i), Float64(x * z)), Float64(b * fma(c, Float64(-z), Float64(a * i)))) tmp = 0.0 if (y <= -3.8e-71) tmp = t_1; elseif (y <= 1.1e+220) tmp = fma(z, fma(b, Float64(-c), Float64(x * y)), Float64(a * fma(t, Float64(-x), Float64(b * i)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.8e-71], t$95$1, If[LessEqual[y, 1.1e+220], N[(z * N[(b * (-c) + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y, \mathsf{fma}\left(j, -i, x \cdot z\right), b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\right)\\
\mathbf{if}\;y \leq -3.8 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.1 \cdot 10^{+220}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(b, -c, x \cdot y\right), a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -3.79999999999999992e-71 or 1.09999999999999995e220 < y Initial program 76.0%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Applied rewrites82.4%
if -3.79999999999999992e-71 < y < 1.09999999999999995e220Initial program 71.2%
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-/.f6471.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6471.2
lift-*.f64N/A
*-commutativeN/A
lower-*.f6471.2
Applied rewrites71.2%
Taylor expanded in j around 0
Applied rewrites76.4%
Final simplification78.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.1e+57)
(fma j (fma c t (* y (- i))) (* a (fma t (- x) (* b i))))
(if (<= i 3.7e+36)
(fma c (fma j t (* z (- b))) (* x (- (* y z) (* t a))))
(fma y (fma j (- i) (* x z)) (* b (fma c (- z) (* a i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.1e+57) {
tmp = fma(j, fma(c, t, (y * -i)), (a * fma(t, -x, (b * i))));
} else if (i <= 3.7e+36) {
tmp = fma(c, fma(j, t, (z * -b)), (x * ((y * z) - (t * a))));
} else {
tmp = fma(y, fma(j, -i, (x * z)), (b * fma(c, -z, (a * i))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.1e+57) tmp = fma(j, fma(c, t, Float64(y * Float64(-i))), Float64(a * fma(t, Float64(-x), Float64(b * i)))); elseif (i <= 3.7e+36) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); else tmp = fma(y, fma(j, Float64(-i), Float64(x * z)), Float64(b * fma(c, Float64(-z), Float64(a * i)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.1e+57], N[(j * N[(c * t + N[(y * (-i)), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.7e+36], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.1 \cdot 10^{+57}:\\
\;\;\;\;\mathsf{fma}\left(j, \mathsf{fma}\left(c, t, y \cdot \left(-i\right)\right), a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\right)\\
\mathbf{elif}\;i \leq 3.7 \cdot 10^{+36}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(j, -i, x \cdot z\right), b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\right)\\
\end{array}
\end{array}
if i < -1.1e57Initial program 63.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
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Applied rewrites87.3%
if -1.1e57 < i < 3.70000000000000029e36Initial program 78.5%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.8%
if 3.70000000000000029e36 < i Initial program 66.4%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
lower-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
sub-negN/A
Applied rewrites78.1%
Final simplification77.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.1e+57)
(fma j (fma c t (* y (- i))) (* a (fma t (- x) (* b i))))
(if (<= i 1.06e+55)
(fma c (fma j t (* z (- b))) (* x (- (* y z) (* t a))))
(* i (fma b a (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.1e+57) {
tmp = fma(j, fma(c, t, (y * -i)), (a * fma(t, -x, (b * i))));
} else if (i <= 1.06e+55) {
tmp = fma(c, fma(j, t, (z * -b)), (x * ((y * z) - (t * a))));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.1e+57) tmp = fma(j, fma(c, t, Float64(y * Float64(-i))), Float64(a * fma(t, Float64(-x), Float64(b * i)))); elseif (i <= 1.06e+55) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.1e+57], N[(j * N[(c * t + N[(y * (-i)), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.06e+55], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.1 \cdot 10^{+57}:\\
\;\;\;\;\mathsf{fma}\left(j, \mathsf{fma}\left(c, t, y \cdot \left(-i\right)\right), a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\right)\\
\mathbf{elif}\;i \leq 1.06 \cdot 10^{+55}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -1.1e57Initial program 63.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
cancel-sign-subN/A
associate-*r*N/A
mul-1-negN/A
distribute-lft-out--N/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-out--N/A
lower-fma.f64N/A
Applied rewrites87.3%
if -1.1e57 < i < 1.06000000000000004e55Initial program 78.2%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.5%
if 1.06000000000000004e55 < i Initial program 66.8%
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-/.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
Applied rewrites66.8%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.3
Applied rewrites74.3%
Final simplification76.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -3.25e+66)
(* i (fma j (- y) (* a b)))
(if (<= i 1.06e+55)
(fma c (fma j t (* z (- b))) (* x (- (* y z) (* t a))))
(* i (fma b a (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -3.25e+66) {
tmp = i * fma(j, -y, (a * b));
} else if (i <= 1.06e+55) {
tmp = fma(c, fma(j, t, (z * -b)), (x * ((y * z) - (t * a))));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -3.25e+66) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); elseif (i <= 1.06e+55) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -3.25e+66], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.06e+55], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -3.25 \cdot 10^{+66}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{elif}\;i \leq 1.06 \cdot 10^{+55}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -3.2500000000000001e66Initial program 63.8%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6482.0
Applied rewrites82.0%
if -3.2500000000000001e66 < i < 1.06000000000000004e55Initial program 78.2%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.5%
if 1.06000000000000004e55 < i Initial program 66.8%
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-/.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
Applied rewrites66.8%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.3
Applied rewrites74.3%
Final simplification75.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -7.4e+83)
(* i (fma j (- y) (* a b)))
(if (<= i -4e-204)
(fma z (fma b (- c) (* x y)) (* b (* a i)))
(if (<= i 1.95e+54)
(fma c (fma j t (* z (- b))) (* x (* y z)))
(* i (fma b a (* y (- j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -7.4e+83) {
tmp = i * fma(j, -y, (a * b));
} else if (i <= -4e-204) {
tmp = fma(z, fma(b, -c, (x * y)), (b * (a * i)));
} else if (i <= 1.95e+54) {
tmp = fma(c, fma(j, t, (z * -b)), (x * (y * z)));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -7.4e+83) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); elseif (i <= -4e-204) tmp = fma(z, fma(b, Float64(-c), Float64(x * y)), Float64(b * Float64(a * i))); elseif (i <= 1.95e+54) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(y * z))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -7.4e+83], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -4e-204], N[(z * N[(b * (-c) + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.95e+54], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -7.4 \cdot 10^{+83}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{elif}\;i \leq -4 \cdot 10^{-204}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(b, -c, x \cdot y\right), b \cdot \left(a \cdot i\right)\right)\\
\mathbf{elif}\;i \leq 1.95 \cdot 10^{+54}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -7.4000000000000005e83Initial program 63.0%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6481.7
Applied rewrites81.7%
if -7.4000000000000005e83 < i < -4e-204Initial program 78.6%
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-/.f6478.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.5
lift-*.f64N/A
*-commutativeN/A
lower-*.f6478.5
Applied rewrites78.5%
Taylor expanded in j around 0
Applied rewrites75.6%
Taylor expanded in t around 0
Applied rewrites71.8%
if -4e-204 < i < 1.9500000000000001e54Initial program 78.2%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites77.3%
Taylor expanded in y around inf
Applied rewrites63.0%
if 1.9500000000000001e54 < i Initial program 66.8%
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-/.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
Applied rewrites66.8%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.3
Applied rewrites74.3%
Final simplification70.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (fma c (- z) (* a i)))))
(if (<= b -9200000000000.0)
t_1
(if (<= b 1.65e-111)
(+ (* z (* x y)) (- (* y (* i j))))
(if (<= b 7e-55)
(* t (fma j c (* x (- a))))
(if (<= b 1.35e+94) (* z (fma c (- b) (* x y))) 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 = b * fma(c, -z, (a * i));
double tmp;
if (b <= -9200000000000.0) {
tmp = t_1;
} else if (b <= 1.65e-111) {
tmp = (z * (x * y)) + -(y * (i * j));
} else if (b <= 7e-55) {
tmp = t * fma(j, c, (x * -a));
} else if (b <= 1.35e+94) {
tmp = z * fma(c, -b, (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(c, Float64(-z), Float64(a * i))) tmp = 0.0 if (b <= -9200000000000.0) tmp = t_1; elseif (b <= 1.65e-111) tmp = Float64(Float64(z * Float64(x * y)) + Float64(-Float64(y * Float64(i * j)))); elseif (b <= 7e-55) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (b <= 1.35e+94) tmp = Float64(z * fma(c, Float64(-b), Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -9200000000000.0], t$95$1, If[LessEqual[b, 1.65e-111], N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] + (-N[(y * N[(i * j), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[b, 7e-55], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.35e+94], N[(z * N[(c * (-b) + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\\
\mathbf{if}\;b \leq -9200000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.65 \cdot 10^{-111}:\\
\;\;\;\;z \cdot \left(x \cdot y\right) + \left(-y \cdot \left(i \cdot j\right)\right)\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-55}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{+94}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, -b, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -9.2e12 or 1.3500000000000001e94 < b Initial program 74.8%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6472.0
Applied rewrites72.0%
if -9.2e12 < b < 1.65e-111Initial program 68.6%
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-/.f6468.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6468.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6468.7
Applied rewrites68.7%
Taylor expanded in y around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6463.7
Applied rewrites63.7%
Taylor expanded in c around 0
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6457.6
Applied rewrites57.6%
if 1.65e-111 < b < 7.00000000000000051e-55Initial program 91.4%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6491.2
Applied rewrites91.2%
if 7.00000000000000051e-55 < b < 1.3500000000000001e94Initial program 72.4%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6466.4
Applied rewrites66.4%
Final simplification66.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (fma c (- z) (* a i)))))
(if (<= b -5400.0)
t_1
(if (<= b 1.95e-111)
(* y (fma j (- i) (* x z)))
(if (<= b 7e-55)
(* t (fma j c (* x (- a))))
(if (<= b 1.35e+94) (* z (fma c (- b) (* x y))) 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 = b * fma(c, -z, (a * i));
double tmp;
if (b <= -5400.0) {
tmp = t_1;
} else if (b <= 1.95e-111) {
tmp = y * fma(j, -i, (x * z));
} else if (b <= 7e-55) {
tmp = t * fma(j, c, (x * -a));
} else if (b <= 1.35e+94) {
tmp = z * fma(c, -b, (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(c, Float64(-z), Float64(a * i))) tmp = 0.0 if (b <= -5400.0) tmp = t_1; elseif (b <= 1.95e-111) tmp = Float64(y * fma(j, Float64(-i), Float64(x * z))); elseif (b <= 7e-55) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (b <= 1.35e+94) tmp = Float64(z * fma(c, Float64(-b), Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5400.0], t$95$1, If[LessEqual[b, 1.95e-111], N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7e-55], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.35e+94], N[(z * N[(c * (-b) + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\\
\mathbf{if}\;b \leq -5400:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.95 \cdot 10^{-111}:\\
\;\;\;\;y \cdot \mathsf{fma}\left(j, -i, x \cdot z\right)\\
\mathbf{elif}\;b \leq 7 \cdot 10^{-55}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{+94}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, -b, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5400 or 1.3500000000000001e94 < b Initial program 75.2%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.7
Applied rewrites71.7%
if -5400 < b < 1.9500000000000001e-111Initial program 68.0%
Taylor expanded in y around inf
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.3
Applied rewrites56.3%
if 1.9500000000000001e-111 < b < 7.00000000000000051e-55Initial program 91.4%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6491.2
Applied rewrites91.2%
if 7.00000000000000051e-55 < b < 1.3500000000000001e94Initial program 72.4%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6466.4
Applied rewrites66.4%
Final simplification66.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -2.2e+29)
t_1
(if (<= i -7.5e-271)
(* t (fma j c (* x (- a))))
(if (<= i 7.6e-107)
(* c (fma j t (* z (- b))))
(if (<= i 8.2e+53) (* x (- (* y z) (* t 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 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -2.2e+29) {
tmp = t_1;
} else if (i <= -7.5e-271) {
tmp = t * fma(j, c, (x * -a));
} else if (i <= 7.6e-107) {
tmp = c * fma(j, t, (z * -b));
} else if (i <= 8.2e+53) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -2.2e+29) tmp = t_1; elseif (i <= -7.5e-271) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (i <= 7.6e-107) tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); elseif (i <= 8.2e+53) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.2e+29], t$95$1, If[LessEqual[i, -7.5e-271], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 7.6e-107], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 8.2e+53], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -2.2 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -7.5 \cdot 10^{-271}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;i \leq 7.6 \cdot 10^{-107}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{elif}\;i \leq 8.2 \cdot 10^{+53}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -2.2000000000000001e29 or 8.20000000000000037e53 < i Initial program 65.0%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.8
Applied rewrites76.8%
if -2.2000000000000001e29 < i < -7.50000000000000031e-271Initial program 78.5%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6451.2
Applied rewrites51.2%
if -7.50000000000000031e-271 < i < 7.6000000000000004e-107Initial program 81.0%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6455.7
Applied rewrites55.7%
if 7.6000000000000004e-107 < i < 8.20000000000000037e53Initial program 76.1%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6456.2
Applied rewrites56.2%
Final simplification63.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -2.2e+29)
t_1
(if (<= i -7.5e-271)
(* t (fma j c (* x (- a))))
(if (<= i 3.1e-86)
(* c (fma j t (* z (- b))))
(if (<= i 7.2e+74) (* a (fma t (- x) (* b 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 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -2.2e+29) {
tmp = t_1;
} else if (i <= -7.5e-271) {
tmp = t * fma(j, c, (x * -a));
} else if (i <= 3.1e-86) {
tmp = c * fma(j, t, (z * -b));
} else if (i <= 7.2e+74) {
tmp = a * fma(t, -x, (b * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -2.2e+29) tmp = t_1; elseif (i <= -7.5e-271) tmp = Float64(t * fma(j, c, Float64(x * Float64(-a)))); elseif (i <= 3.1e-86) tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); elseif (i <= 7.2e+74) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.2e+29], t$95$1, If[LessEqual[i, -7.5e-271], N[(t * N[(j * c + N[(x * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.1e-86], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 7.2e+74], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -2.2 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -7.5 \cdot 10^{-271}:\\
\;\;\;\;t \cdot \mathsf{fma}\left(j, c, x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;i \leq 3.1 \cdot 10^{-86}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{elif}\;i \leq 7.2 \cdot 10^{+74}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -2.2000000000000001e29 or 7.19999999999999975e74 < i Initial program 63.7%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.8
Applied rewrites76.8%
if -2.2000000000000001e29 < i < -7.50000000000000031e-271Initial program 78.5%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6451.2
Applied rewrites51.2%
if -7.50000000000000031e-271 < i < 3.09999999999999989e-86Initial program 81.2%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6453.5
Applied rewrites53.5%
if 3.09999999999999989e-86 < i < 7.19999999999999975e74Initial program 78.0%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.7
Applied rewrites56.7%
Final simplification63.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (fma j t (* z (- b))))))
(if (<= c -2.1e+102)
t_1
(if (<= c -3.2e+75)
(* z (* x y))
(if (<= c 190.0)
(* a (fma t (- x) (* b i)))
(if (<= c 5.7e+187) t_1 (* b (fma c (- z) (* a i)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * fma(j, t, (z * -b));
double tmp;
if (c <= -2.1e+102) {
tmp = t_1;
} else if (c <= -3.2e+75) {
tmp = z * (x * y);
} else if (c <= 190.0) {
tmp = a * fma(t, -x, (b * i));
} else if (c <= 5.7e+187) {
tmp = t_1;
} else {
tmp = b * fma(c, -z, (a * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * fma(j, t, Float64(z * Float64(-b)))) tmp = 0.0 if (c <= -2.1e+102) tmp = t_1; elseif (c <= -3.2e+75) tmp = Float64(z * Float64(x * y)); elseif (c <= 190.0) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); elseif (c <= 5.7e+187) tmp = t_1; else tmp = Float64(b * fma(c, Float64(-z), Float64(a * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2.1e+102], t$95$1, If[LessEqual[c, -3.2e+75], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 190.0], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.7e+187], t$95$1, N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{if}\;c \leq -2.1 \cdot 10^{+102}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq -3.2 \cdot 10^{+75}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;c \leq 190:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{elif}\;c \leq 5.7 \cdot 10^{+187}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\\
\end{array}
\end{array}
if c < -2.10000000000000001e102 or 190 < c < 5.7000000000000004e187Initial program 58.1%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6464.6
Applied rewrites64.6%
if -2.10000000000000001e102 < c < -3.19999999999999985e75Initial program 99.8%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites94.2%
Taylor expanded in j around inf
Applied rewrites14.4%
Taylor expanded in y around inf
Applied rewrites94.2%
if -3.19999999999999985e75 < c < 190Initial program 80.4%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.3
Applied rewrites54.3%
if 5.7000000000000004e187 < c Initial program 59.9%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.7
Applied rewrites80.7%
Final simplification60.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -3e+66)
(* i (fma j (- y) (* a b)))
(if (<= i 1.95e+54)
(fma c (fma j t (* z (- b))) (* x (* y z)))
(* i (fma b a (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -3e+66) {
tmp = i * fma(j, -y, (a * b));
} else if (i <= 1.95e+54) {
tmp = fma(c, fma(j, t, (z * -b)), (x * (y * z)));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -3e+66) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); elseif (i <= 1.95e+54) tmp = fma(c, fma(j, t, Float64(z * Float64(-b))), Float64(x * Float64(y * z))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -3e+66], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.95e+54], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision] + N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -3 \cdot 10^{+66}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{elif}\;i \leq 1.95 \cdot 10^{+54}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right), x \cdot \left(y \cdot z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -3.00000000000000002e66Initial program 63.8%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6482.0
Applied rewrites82.0%
if -3.00000000000000002e66 < i < 1.9500000000000001e54Initial program 78.2%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites74.5%
Taylor expanded in y around inf
Applied rewrites60.5%
if 1.9500000000000001e54 < i Initial program 66.8%
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-/.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
Applied rewrites66.8%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.3
Applied rewrites74.3%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (fma c (- z) (* a i)))))
(if (<= b -5400.0)
t_1
(if (<= b 1.1e-128)
(* y (fma j (- i) (* x z)))
(if (<= b 1.52e+94) (* x (- (* y z) (* t 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 = b * fma(c, -z, (a * i));
double tmp;
if (b <= -5400.0) {
tmp = t_1;
} else if (b <= 1.1e-128) {
tmp = y * fma(j, -i, (x * z));
} else if (b <= 1.52e+94) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(c, Float64(-z), Float64(a * i))) tmp = 0.0 if (b <= -5400.0) tmp = t_1; elseif (b <= 1.1e-128) tmp = Float64(y * fma(j, Float64(-i), Float64(x * z))); elseif (b <= 1.52e+94) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5400.0], t$95$1, If[LessEqual[b, 1.1e-128], N[(y * N[(j * (-i) + N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.52e+94], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\\
\mathbf{if}\;b \leq -5400:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.1 \cdot 10^{-128}:\\
\;\;\;\;y \cdot \mathsf{fma}\left(j, -i, x \cdot z\right)\\
\mathbf{elif}\;b \leq 1.52 \cdot 10^{+94}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5400 or 1.5199999999999999e94 < b Initial program 75.2%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.7
Applied rewrites71.7%
if -5400 < b < 1.10000000000000005e-128Initial program 68.1%
Taylor expanded in y around inf
lower-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6455.9
Applied rewrites55.9%
if 1.10000000000000005e-128 < b < 1.5199999999999999e94Initial program 78.4%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6460.3
Applied rewrites60.3%
Final simplification64.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -2.2e+29)
t_1
(if (<= i 3.1e-86)
(* c (fma j t (* z (- b))))
(if (<= i 7.2e+74) (* a (fma t (- x) (* b 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 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -2.2e+29) {
tmp = t_1;
} else if (i <= 3.1e-86) {
tmp = c * fma(j, t, (z * -b));
} else if (i <= 7.2e+74) {
tmp = a * fma(t, -x, (b * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -2.2e+29) tmp = t_1; elseif (i <= 3.1e-86) tmp = Float64(c * fma(j, t, Float64(z * Float64(-b)))); elseif (i <= 7.2e+74) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.2e+29], t$95$1, If[LessEqual[i, 3.1e-86], N[(c * N[(j * t + N[(z * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 7.2e+74], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -2.2 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 3.1 \cdot 10^{-86}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(-b\right)\right)\\
\mathbf{elif}\;i \leq 7.2 \cdot 10^{+74}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -2.2000000000000001e29 or 7.19999999999999975e74 < i Initial program 63.7%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6476.8
Applied rewrites76.8%
if -2.2000000000000001e29 < i < 3.09999999999999989e-86Initial program 79.8%
Taylor expanded in c around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6447.3
Applied rewrites47.3%
if 3.09999999999999989e-86 < i < 7.19999999999999975e74Initial program 78.0%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.7
Applied rewrites56.7%
Final simplification60.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (fma t (- x) (* b i)))))
(if (<= a -5e+25)
t_1
(if (<= a 1.4e-175)
(* z (* x y))
(if (<= a 1.08e-97) (* z (* c (- 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 = a * fma(t, -x, (b * i));
double tmp;
if (a <= -5e+25) {
tmp = t_1;
} else if (a <= 1.4e-175) {
tmp = z * (x * y);
} else if (a <= 1.08e-97) {
tmp = z * (c * -b);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * fma(t, Float64(-x), Float64(b * i))) tmp = 0.0 if (a <= -5e+25) tmp = t_1; elseif (a <= 1.4e-175) tmp = Float64(z * Float64(x * y)); elseif (a <= 1.08e-97) tmp = Float64(z * Float64(c * Float64(-b))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5e+25], t$95$1, If[LessEqual[a, 1.4e-175], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.08e-97], N[(z * N[(c * (-b)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{if}\;a \leq -5 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{-175}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;a \leq 1.08 \cdot 10^{-97}:\\
\;\;\;\;z \cdot \left(c \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -5.00000000000000024e25 or 1.0799999999999999e-97 < a Initial program 69.4%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6464.0
Applied rewrites64.0%
if -5.00000000000000024e25 < a < 1.4e-175Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites67.1%
Taylor expanded in j around inf
Applied rewrites21.2%
Taylor expanded in y around inf
Applied rewrites38.9%
if 1.4e-175 < a < 1.0799999999999999e-97Initial program 67.8%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites61.1%
Taylor expanded in j around inf
Applied rewrites16.0%
Taylor expanded in b around inf
Applied rewrites56.1%
Final simplification54.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -3.8e+26)
(* a (* b i))
(if (<= a 1.4e-175)
(* z (* x y))
(if (<= a 5e-6) (* z (* c (- b))) (* b (* a i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -3.8e+26) {
tmp = a * (b * i);
} else if (a <= 1.4e-175) {
tmp = z * (x * y);
} else if (a <= 5e-6) {
tmp = z * (c * -b);
} else {
tmp = b * (a * i);
}
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 (a <= (-3.8d+26)) then
tmp = a * (b * i)
else if (a <= 1.4d-175) then
tmp = z * (x * y)
else if (a <= 5d-6) then
tmp = z * (c * -b)
else
tmp = b * (a * i)
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 (a <= -3.8e+26) {
tmp = a * (b * i);
} else if (a <= 1.4e-175) {
tmp = z * (x * y);
} else if (a <= 5e-6) {
tmp = z * (c * -b);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -3.8e+26: tmp = a * (b * i) elif a <= 1.4e-175: tmp = z * (x * y) elif a <= 5e-6: tmp = z * (c * -b) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -3.8e+26) tmp = Float64(a * Float64(b * i)); elseif (a <= 1.4e-175) tmp = Float64(z * Float64(x * y)); elseif (a <= 5e-6) tmp = Float64(z * Float64(c * Float64(-b))); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -3.8e+26) tmp = a * (b * i); elseif (a <= 1.4e-175) tmp = z * (x * y); elseif (a <= 5e-6) tmp = z * (c * -b); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -3.8e+26], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.4e-175], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e-6], N[(z * N[(c * (-b)), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.8 \cdot 10^{+26}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;a \leq 1.4 \cdot 10^{-175}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;a \leq 5 \cdot 10^{-6}:\\
\;\;\;\;z \cdot \left(c \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if a < -3.8000000000000002e26Initial program 67.4%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.5
Applied rewrites69.5%
Taylor expanded in t around 0
Applied rewrites50.2%
if -3.8000000000000002e26 < a < 1.4e-175Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites67.1%
Taylor expanded in j around inf
Applied rewrites21.2%
Taylor expanded in y around inf
Applied rewrites38.9%
if 1.4e-175 < a < 5.00000000000000041e-6Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites64.1%
Taylor expanded in j around inf
Applied rewrites20.5%
Taylor expanded in b around inf
Applied rewrites46.8%
if 5.00000000000000041e-6 < a Initial program 65.0%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.9
Applied rewrites51.9%
Taylor expanded in c around 0
Applied rewrites42.7%
Final simplification43.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -3.8e+26)
(* a (* b i))
(if (<= a 2.35e-175)
(* z (* x y))
(if (<= a 3.5e-5) (- (* b (* z c))) (* b (* a i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= -3.8e+26) {
tmp = a * (b * i);
} else if (a <= 2.35e-175) {
tmp = z * (x * y);
} else if (a <= 3.5e-5) {
tmp = -(b * (z * c));
} else {
tmp = b * (a * i);
}
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 (a <= (-3.8d+26)) then
tmp = a * (b * i)
else if (a <= 2.35d-175) then
tmp = z * (x * y)
else if (a <= 3.5d-5) then
tmp = -(b * (z * c))
else
tmp = b * (a * i)
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 (a <= -3.8e+26) {
tmp = a * (b * i);
} else if (a <= 2.35e-175) {
tmp = z * (x * y);
} else if (a <= 3.5e-5) {
tmp = -(b * (z * c));
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -3.8e+26: tmp = a * (b * i) elif a <= 2.35e-175: tmp = z * (x * y) elif a <= 3.5e-5: tmp = -(b * (z * c)) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -3.8e+26) tmp = Float64(a * Float64(b * i)); elseif (a <= 2.35e-175) tmp = Float64(z * Float64(x * y)); elseif (a <= 3.5e-5) tmp = Float64(-Float64(b * Float64(z * c))); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -3.8e+26) tmp = a * (b * i); elseif (a <= 2.35e-175) tmp = z * (x * y); elseif (a <= 3.5e-5) tmp = -(b * (z * c)); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -3.8e+26], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.35e-175], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.5e-5], (-N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -3.8 \cdot 10^{+26}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;a \leq 2.35 \cdot 10^{-175}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;a \leq 3.5 \cdot 10^{-5}:\\
\;\;\;\;-b \cdot \left(z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if a < -3.8000000000000002e26Initial program 67.4%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.5
Applied rewrites69.5%
Taylor expanded in t around 0
Applied rewrites50.2%
if -3.8000000000000002e26 < a < 2.34999999999999999e-175Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites67.1%
Taylor expanded in j around inf
Applied rewrites21.2%
Taylor expanded in y around inf
Applied rewrites38.9%
if 2.34999999999999999e-175 < a < 3.4999999999999997e-5Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites64.1%
Taylor expanded in b around inf
Applied rewrites41.8%
if 3.4999999999999997e-5 < a Initial program 65.0%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.9
Applied rewrites51.9%
Taylor expanded in c around 0
Applied rewrites42.7%
Final simplification42.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.1e+57)
(* i (fma j (- y) (* a b)))
(if (<= i 2.15e+54)
(* z (fma x y (* c (- b))))
(* i (fma b a (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.1e+57) {
tmp = i * fma(j, -y, (a * b));
} else if (i <= 2.15e+54) {
tmp = z * fma(x, y, (c * -b));
} else {
tmp = i * fma(b, a, (y * -j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.1e+57) tmp = Float64(i * fma(j, Float64(-y), Float64(a * b))); elseif (i <= 2.15e+54) tmp = Float64(z * fma(x, y, Float64(c * Float64(-b)))); else tmp = Float64(i * fma(b, a, Float64(y * Float64(-j)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.1e+57], N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.15e+54], N[(z * N[(x * y + N[(c * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(b * a + N[(y * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.1 \cdot 10^{+57}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{elif}\;i \leq 2.15 \cdot 10^{+54}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(x, y, c \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(b, a, y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -1.1e57Initial program 63.8%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6482.0
Applied rewrites82.0%
if -1.1e57 < i < 2.14999999999999988e54Initial program 78.2%
Taylor expanded in z around inf
Applied rewrites78.7%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6453.3
Applied rewrites53.3%
if 2.14999999999999988e54 < i Initial program 66.8%
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-/.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
lift-*.f64N/A
*-commutativeN/A
lower-*.f6466.8
Applied rewrites66.8%
Taylor expanded in i around inf
lower-*.f64N/A
associate-*r*N/A
mul-1-negN/A
cancel-sign-subN/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6474.3
Applied rewrites74.3%
Final simplification63.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- y) (* a b)))))
(if (<= i -1.1e+57)
t_1
(if (<= i 2.15e+54) (* z (fma x y (* c (- 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 = i * fma(j, -y, (a * b));
double tmp;
if (i <= -1.1e+57) {
tmp = t_1;
} else if (i <= 2.15e+54) {
tmp = z * fma(x, y, (c * -b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(-y), Float64(a * b))) tmp = 0.0 if (i <= -1.1e+57) tmp = t_1; elseif (i <= 2.15e+54) tmp = Float64(z * fma(x, y, Float64(c * Float64(-b)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * (-y) + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.1e+57], t$95$1, If[LessEqual[i, 2.15e+54], N[(z * N[(x * y + N[(c * (-b)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, -y, a \cdot b\right)\\
\mathbf{if}\;i \leq -1.1 \cdot 10^{+57}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 2.15 \cdot 10^{+54}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(x, y, c \cdot \left(-b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.1e57 or 2.14999999999999988e54 < i Initial program 65.5%
Taylor expanded in i around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6477.7
Applied rewrites77.7%
if -1.1e57 < i < 2.14999999999999988e54Initial program 78.2%
Taylor expanded in z around inf
Applied rewrites78.7%
Taylor expanded in z around inf
lower-*.f64N/A
sub-negN/A
lower-fma.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6453.3
Applied rewrites53.3%
Final simplification63.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (fma c (- z) (* a i)))))
(if (<= b -3800.0)
t_1
(if (<= b 1.08e+24) (* a (fma t (- x) (* b 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 = b * fma(c, -z, (a * i));
double tmp;
if (b <= -3800.0) {
tmp = t_1;
} else if (b <= 1.08e+24) {
tmp = a * fma(t, -x, (b * i));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(c, Float64(-z), Float64(a * i))) tmp = 0.0 if (b <= -3800.0) tmp = t_1; elseif (b <= 1.08e+24) tmp = Float64(a * fma(t, Float64(-x), Float64(b * i))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(c * (-z) + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3800.0], t$95$1, If[LessEqual[b, 1.08e+24], N[(a * N[(t * (-x) + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(c, -z, a \cdot i\right)\\
\mathbf{if}\;b \leq -3800:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.08 \cdot 10^{+24}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(t, -x, b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -3800 or 1.0799999999999999e24 < b Initial program 75.4%
Taylor expanded in b around inf
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-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6470.0
Applied rewrites70.0%
if -3800 < b < 1.0799999999999999e24Initial program 70.1%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.8
Applied rewrites39.8%
Final simplification55.7%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* z (* x y)))) (if (<= x -2.65e+94) t_1 (if (<= x 2.8e-19) (* a (* b 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 = z * (x * y);
double tmp;
if (x <= -2.65e+94) {
tmp = t_1;
} else if (x <= 2.8e-19) {
tmp = a * (b * 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 = z * (x * y)
if (x <= (-2.65d+94)) then
tmp = t_1
else if (x <= 2.8d-19) then
tmp = a * (b * 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 = z * (x * y);
double tmp;
if (x <= -2.65e+94) {
tmp = t_1;
} else if (x <= 2.8e-19) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if x <= -2.65e+94: tmp = t_1 elif x <= 2.8e-19: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -2.65e+94) tmp = t_1; elseif (x <= 2.8e-19) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (x <= -2.65e+94) tmp = t_1; elseif (x <= 2.8e-19) tmp = a * (b * 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[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.65e+94], t$95$1, If[LessEqual[x, 2.8e-19], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -2.65 \cdot 10^{+94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.8 \cdot 10^{-19}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -2.65000000000000002e94 or 2.80000000000000003e-19 < x Initial program 74.3%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites71.5%
Taylor expanded in j around inf
Applied rewrites13.1%
Taylor expanded in y around inf
Applied rewrites47.8%
if -2.65000000000000002e94 < x < 2.80000000000000003e-19Initial program 72.0%
Taylor expanded in a around inf
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6445.4
Applied rewrites45.4%
Taylor expanded in t around 0
Applied rewrites36.1%
Final simplification40.6%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= j -2.2e+156) (* c (* t j)) (if (<= j 3.6e+189) (* z (* x y)) (* j (* t c)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -2.2e+156) {
tmp = c * (t * j);
} else if (j <= 3.6e+189) {
tmp = z * (x * y);
} else {
tmp = j * (t * c);
}
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 (j <= (-2.2d+156)) then
tmp = c * (t * j)
else if (j <= 3.6d+189) then
tmp = z * (x * y)
else
tmp = j * (t * c)
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 (j <= -2.2e+156) {
tmp = c * (t * j);
} else if (j <= 3.6e+189) {
tmp = z * (x * y);
} else {
tmp = j * (t * c);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if j <= -2.2e+156: tmp = c * (t * j) elif j <= 3.6e+189: tmp = z * (x * y) else: tmp = j * (t * c) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -2.2e+156) tmp = Float64(c * Float64(t * j)); elseif (j <= 3.6e+189) tmp = Float64(z * Float64(x * y)); else tmp = Float64(j * Float64(t * c)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (j <= -2.2e+156) tmp = c * (t * j); elseif (j <= 3.6e+189) tmp = z * (x * y); else tmp = j * (t * c); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -2.2e+156], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 3.6e+189], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -2.2 \cdot 10^{+156}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;j \leq 3.6 \cdot 10^{+189}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\end{array}
\end{array}
if j < -2.20000000000000004e156Initial program 75.7%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites42.1%
Taylor expanded in j around inf
Applied rewrites35.4%
if -2.20000000000000004e156 < j < 3.60000000000000008e189Initial program 72.6%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites61.7%
Taylor expanded in j around inf
Applied rewrites9.6%
Taylor expanded in y around inf
Applied rewrites29.0%
if 3.60000000000000008e189 < j Initial program 71.9%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites68.5%
Taylor expanded in j around inf
Applied rewrites53.3%
Applied rewrites53.3%
Final simplification32.1%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* c (* t j)))) (if (<= j -2.2e+156) t_1 (if (<= j 4e+189) (* z (* x y)) 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 = c * (t * j);
double tmp;
if (j <= -2.2e+156) {
tmp = t_1;
} else if (j <= 4e+189) {
tmp = z * (x * y);
} 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 = c * (t * j)
if (j <= (-2.2d+156)) then
tmp = t_1
else if (j <= 4d+189) then
tmp = z * (x * y)
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 = c * (t * j);
double tmp;
if (j <= -2.2e+156) {
tmp = t_1;
} else if (j <= 4e+189) {
tmp = z * (x * y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if j <= -2.2e+156: tmp = t_1 elif j <= 4e+189: tmp = z * (x * y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (j <= -2.2e+156) tmp = t_1; elseif (j <= 4e+189) tmp = Float64(z * Float64(x * y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (j <= -2.2e+156) tmp = t_1; elseif (j <= 4e+189) tmp = z * (x * y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2.2e+156], t$95$1, If[LessEqual[j, 4e+189], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;j \leq -2.2 \cdot 10^{+156}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 4 \cdot 10^{+189}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.20000000000000004e156 or 4.0000000000000001e189 < j Initial program 74.0%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites54.3%
Taylor expanded in j around inf
Applied rewrites43.7%
if -2.20000000000000004e156 < j < 4.0000000000000001e189Initial program 72.6%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites61.7%
Taylor expanded in j around inf
Applied rewrites9.6%
Taylor expanded in y around inf
Applied rewrites29.0%
Final simplification32.1%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* c (* t j)))) (if (<= j -2.2e+156) t_1 (if (<= j 2.2e+190) (* x (* y 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 = c * (t * j);
double tmp;
if (j <= -2.2e+156) {
tmp = t_1;
} else if (j <= 2.2e+190) {
tmp = x * (y * 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 = c * (t * j)
if (j <= (-2.2d+156)) then
tmp = t_1
else if (j <= 2.2d+190) then
tmp = x * (y * 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 = c * (t * j);
double tmp;
if (j <= -2.2e+156) {
tmp = t_1;
} else if (j <= 2.2e+190) {
tmp = x * (y * z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if j <= -2.2e+156: tmp = t_1 elif j <= 2.2e+190: tmp = x * (y * z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (j <= -2.2e+156) tmp = t_1; elseif (j <= 2.2e+190) tmp = Float64(x * Float64(y * z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (j <= -2.2e+156) tmp = t_1; elseif (j <= 2.2e+190) tmp = x * (y * 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[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2.2e+156], t$95$1, If[LessEqual[j, 2.2e+190], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;j \leq -2.2 \cdot 10^{+156}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 2.2 \cdot 10^{+190}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.20000000000000004e156 or 2.2e190 < j Initial program 74.0%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites54.3%
Taylor expanded in j around inf
Applied rewrites43.7%
if -2.20000000000000004e156 < j < 2.2e190Initial program 72.6%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites61.7%
Taylor expanded in y around inf
Applied rewrites27.5%
(FPCore (x y z t a b c i j) :precision binary64 (* c (* t j)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return c * (t * j);
}
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 = c * (t * j)
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 c * (t * j);
}
def code(x, y, z, t, a, b, c, i, j): return c * (t * j)
function code(x, y, z, t, a, b, c, i, j) return Float64(c * Float64(t * j)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = c * (t * j); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c \cdot \left(t \cdot j\right)
\end{array}
Initial program 72.9%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
lower-fma.f64N/A
Applied rewrites60.1%
Taylor expanded in j around inf
Applied rewrites16.8%
(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 2024220
(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)))))