
(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 24 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 t) (* z y)) x) (* (- (* i a) (* c z)) b))))
(if (<= (- (* (- (* c t) (* i y)) j) t_1) INFINITY)
(- (/ j (/ 1.0 (fma (- y) i (* c t)))) t_1)
(fma (fma (- i) y (* c t)) j (* (* i b) a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b);
double tmp;
if (((((c * t) - (i * y)) * j) - t_1) <= ((double) INFINITY)) {
tmp = (j / (1.0 / fma(-y, i, (c * t)))) - t_1;
} else {
tmp = fma(fma(-i, y, (c * t)), j, ((i * b) * a));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b)) tmp = 0.0 if (Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - t_1) <= Inf) tmp = Float64(Float64(j / Float64(1.0 / fma(Float64(-y), i, Float64(c * t)))) - t_1); else tmp = fma(fma(Float64(-i), y, Float64(c * t)), j, Float64(Float64(i * b) * a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - t$95$1), $MachinePrecision], Infinity], N[(N[(j / N[(1.0 / N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j + N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\\
\mathbf{if}\;\left(c \cdot t - i \cdot y\right) \cdot j - t\_1 \leq \infty:\\
\;\;\;\;\frac{j}{\frac{1}{\mathsf{fma}\left(-y, i, c \cdot t\right)}} - t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot t\right), j, \left(i \cdot b\right) \cdot a\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 90.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-/.f6490.2
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6490.2
Applied rewrites90.2%
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%
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-/.f640.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f640.0
Applied rewrites0.0%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6446.2
Applied rewrites46.2%
Taylor expanded in x around 0
Applied rewrites50.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
/-rgt-identityN/A
*-commutativeN/A
lower-fma.f6459.0
Applied rewrites59.0%
Final simplification84.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(-
(* (- (* c t) (* i y)) j)
(- (* (- (* a t) (* z y)) x) (* (- (* i a) (* c z)) b)))))
(if (<= t_1 INFINITY) t_1 (fma (fma (- i) y (* c t)) j (* (* i b) a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (((c * t) - (i * y)) * j) - ((((a * t) - (z * y)) * x) - (((i * a) - (c * z)) * b));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(fma(-i, y, (c * t)), j, ((i * b) * a));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(Float64(c * t) - Float64(i * y)) * j) - Float64(Float64(Float64(Float64(a * t) - Float64(z * y)) * x) - Float64(Float64(Float64(i * a) - Float64(c * z)) * b))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = fma(fma(Float64(-i), y, Float64(c * t)), j, Float64(Float64(i * b) * a)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision] - N[(N[(N[(N[(a * t), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] - N[(N[(N[(i * a), $MachinePrecision] - N[(c * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j + N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t - i \cdot y\right) \cdot j - \left(\left(a \cdot t - z \cdot y\right) \cdot x - \left(i \cdot a - c \cdot z\right) \cdot b\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot t\right), j, \left(i \cdot b\right) \cdot a\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 90.2%
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%
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-/.f640.0
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f640.0
Applied rewrites0.0%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6446.2
Applied rewrites46.2%
Taylor expanded in x around 0
Applied rewrites50.7%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
/-rgt-identityN/A
*-commutativeN/A
lower-fma.f6459.0
Applied rewrites59.0%
Final simplification84.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma (fma (- z) b (* j t)) c (* (fma (- t) a (* z y)) x)))
(t_2
(+ (* (fma (- t) x (* i b)) a) (/ j (/ 1.0 (fma (- y) i (* c t)))))))
(if (<= a -9.5e+39)
t_2
(if (<= a -5.5e-144)
t_1
(if (<= a 6e-288)
(+ (* (* z x) y) (* (- (* c t) (* i y)) j))
(if (<= a 1.02e-147) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(fma(-z, b, (j * t)), c, (fma(-t, a, (z * y)) * x));
double t_2 = (fma(-t, x, (i * b)) * a) + (j / (1.0 / fma(-y, i, (c * t))));
double tmp;
if (a <= -9.5e+39) {
tmp = t_2;
} else if (a <= -5.5e-144) {
tmp = t_1;
} else if (a <= 6e-288) {
tmp = ((z * x) * y) + (((c * t) - (i * y)) * j);
} else if (a <= 1.02e-147) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(fma(Float64(-z), b, Float64(j * t)), c, Float64(fma(Float64(-t), a, Float64(z * y)) * x)) t_2 = Float64(Float64(fma(Float64(-t), x, Float64(i * b)) * a) + Float64(j / Float64(1.0 / fma(Float64(-y), i, Float64(c * t))))) tmp = 0.0 if (a <= -9.5e+39) tmp = t_2; elseif (a <= -5.5e-144) tmp = t_1; elseif (a <= 6e-288) tmp = Float64(Float64(Float64(z * x) * y) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); elseif (a <= 1.02e-147) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[((-t) * x + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] + N[(j / N[(1.0 / N[((-y) * i + N[(c * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -9.5e+39], t$95$2, If[LessEqual[a, -5.5e-144], t$95$1, If[LessEqual[a, 6e-288], N[(N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.02e-147], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot t\right), c, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
t_2 := \mathsf{fma}\left(-t, x, i \cdot b\right) \cdot a + \frac{j}{\frac{1}{\mathsf{fma}\left(-y, i, c \cdot t\right)}}\\
\mathbf{if}\;a \leq -9.5 \cdot 10^{+39}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -5.5 \cdot 10^{-144}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6 \cdot 10^{-288}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{elif}\;a \leq 1.02 \cdot 10^{-147}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -9.50000000000000011e39 or 1.02e-147 < a Initial program 68.1%
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.1
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6468.1
Applied rewrites68.1%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6472.6
Applied rewrites72.6%
if -9.50000000000000011e39 < a < -5.49999999999999973e-144 or 5.99999999999999998e-288 < a < 1.02e-147Initial program 82.4%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites87.4%
if -5.49999999999999973e-144 < a < 5.99999999999999998e-288Initial program 79.4%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6476.3
Applied rewrites76.3%
Final simplification76.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* z y) x)) (t_2 (* (fma (- z) c (* i a)) b)))
(if (<= b -5.5e+165)
t_2
(if (<= b -7.6e+56)
(fma (* j c) t (* (fma (- a) t (* z y)) x))
(if (<= b -8.2e-105)
(fma (fma (- z) b (* j t)) c t_1)
(if (<= b 4e-136)
(fma (fma (- x) a (* j c)) t t_1)
(if (<= b 3.7e+26)
(+ (* (* z x) y) (* (- (* c t) (* i y)) j))
t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (z * y) * x;
double t_2 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -5.5e+165) {
tmp = t_2;
} else if (b <= -7.6e+56) {
tmp = fma((j * c), t, (fma(-a, t, (z * y)) * x));
} else if (b <= -8.2e-105) {
tmp = fma(fma(-z, b, (j * t)), c, t_1);
} else if (b <= 4e-136) {
tmp = fma(fma(-x, a, (j * c)), t, t_1);
} else if (b <= 3.7e+26) {
tmp = ((z * x) * y) + (((c * t) - (i * y)) * j);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * y) * x) t_2 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -5.5e+165) tmp = t_2; elseif (b <= -7.6e+56) tmp = fma(Float64(j * c), t, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); elseif (b <= -8.2e-105) tmp = fma(fma(Float64(-z), b, Float64(j * t)), c, t_1); elseif (b <= 4e-136) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, t_1); elseif (b <= 3.7e+26) tmp = Float64(Float64(Float64(z * x) * y) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -5.5e+165], t$95$2, If[LessEqual[b, -7.6e+56], N[(N[(j * c), $MachinePrecision] * t + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -8.2e-105], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + t$95$1), $MachinePrecision], If[LessEqual[b, 4e-136], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + t$95$1), $MachinePrecision], If[LessEqual[b, 3.7e+26], N[(N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot y\right) \cdot x\\
t_2 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -5.5 \cdot 10^{+165}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -7.6 \cdot 10^{+56}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot c, t, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;b \leq -8.2 \cdot 10^{-105}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot t\right), c, t\_1\right)\\
\mathbf{elif}\;b \leq 4 \cdot 10^{-136}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, t\_1\right)\\
\mathbf{elif}\;b \leq 3.7 \cdot 10^{+26}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -5.4999999999999998e165 or 3.69999999999999988e26 < b Initial program 79.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.9
Applied rewrites74.9%
if -5.4999999999999998e165 < b < -7.59999999999999991e56Initial program 65.3%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites70.4%
Taylor expanded in b around 0
Applied rewrites75.2%
if -7.59999999999999991e56 < b < -8.20000000000000061e-105Initial program 74.1%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites80.0%
Taylor expanded in y around inf
Applied rewrites71.1%
if -8.20000000000000061e-105 < b < 4.00000000000000001e-136Initial program 74.7%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites63.7%
Taylor expanded in z around 0
Applied rewrites49.7%
Taylor expanded in b around 0
Applied rewrites72.4%
if 4.00000000000000001e-136 < b < 3.69999999999999988e26Initial program 55.5%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6479.4
Applied rewrites79.4%
Final simplification74.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -5.5e+165)
t_1
(if (<= b -3e-111)
(fma (fma (- z) b (* j t)) c (* (fma (- t) a (* z y)) x))
(if (<= b 4e-136)
(fma (fma (- x) a (* j c)) t (* (* z y) x))
(if (<= b 3.7e+26)
(+ (* (* z x) y) (* (- (* c t) (* i y)) j))
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(-z, c, (i * a)) * b;
double tmp;
if (b <= -5.5e+165) {
tmp = t_1;
} else if (b <= -3e-111) {
tmp = fma(fma(-z, b, (j * t)), c, (fma(-t, a, (z * y)) * x));
} else if (b <= 4e-136) {
tmp = fma(fma(-x, a, (j * c)), t, ((z * y) * x));
} else if (b <= 3.7e+26) {
tmp = ((z * x) * y) + (((c * t) - (i * y)) * j);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -5.5e+165) tmp = t_1; elseif (b <= -3e-111) tmp = fma(fma(Float64(-z), b, Float64(j * t)), c, Float64(fma(Float64(-t), a, Float64(z * y)) * x)); elseif (b <= 4e-136) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, Float64(Float64(z * y) * x)); elseif (b <= 3.7e+26) tmp = Float64(Float64(Float64(z * x) * y) + Float64(Float64(Float64(c * t) - Float64(i * y)) * j)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -5.5e+165], t$95$1, If[LessEqual[b, -3e-111], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4e-136], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.7e+26], N[(N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision] + N[(N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -5.5 \cdot 10^{+165}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3 \cdot 10^{-111}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot t\right), c, \mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 4 \cdot 10^{-136}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \left(z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 3.7 \cdot 10^{+26}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y + \left(c \cdot t - i \cdot y\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.4999999999999998e165 or 3.69999999999999988e26 < b Initial program 79.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.9
Applied rewrites74.9%
if -5.4999999999999998e165 < b < -3.00000000000000008e-111Initial program 70.6%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites76.2%
if -3.00000000000000008e-111 < b < 4.00000000000000001e-136Initial program 74.7%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites63.7%
Taylor expanded in z around 0
Applied rewrites49.7%
Taylor expanded in b around 0
Applied rewrites72.4%
if 4.00000000000000001e-136 < b < 3.69999999999999988e26Initial program 55.5%
Taylor expanded in y around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6479.4
Applied rewrites79.4%
Final simplification75.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (* z y) x)) (t_2 (* (fma (- z) c (* i a)) b)))
(if (<= b -5.5e+165)
t_2
(if (<= b -7.6e+56)
(fma (* j c) t (* (fma (- a) t (* z y)) x))
(if (<= b -8.2e-105)
(fma (fma (- z) b (* j t)) c t_1)
(if (<= b 2.05e+21) (fma (fma (- x) a (* j c)) t 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 = (z * y) * x;
double t_2 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -5.5e+165) {
tmp = t_2;
} else if (b <= -7.6e+56) {
tmp = fma((j * c), t, (fma(-a, t, (z * y)) * x));
} else if (b <= -8.2e-105) {
tmp = fma(fma(-z, b, (j * t)), c, t_1);
} else if (b <= 2.05e+21) {
tmp = fma(fma(-x, a, (j * c)), t, t_1);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(z * y) * x) t_2 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -5.5e+165) tmp = t_2; elseif (b <= -7.6e+56) tmp = fma(Float64(j * c), t, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); elseif (b <= -8.2e-105) tmp = fma(fma(Float64(-z), b, Float64(j * t)), c, t_1); elseif (b <= 2.05e+21) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, t_1); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -5.5e+165], t$95$2, If[LessEqual[b, -7.6e+56], N[(N[(j * c), $MachinePrecision] * t + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -8.2e-105], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c + t$95$1), $MachinePrecision], If[LessEqual[b, 2.05e+21], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + t$95$1), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(z \cdot y\right) \cdot x\\
t_2 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -5.5 \cdot 10^{+165}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -7.6 \cdot 10^{+56}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot c, t, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;b \leq -8.2 \cdot 10^{-105}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-z, b, j \cdot t\right), c, t\_1\right)\\
\mathbf{elif}\;b \leq 2.05 \cdot 10^{+21}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -5.4999999999999998e165 or 2.05e21 < b Initial program 79.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.1
Applied rewrites74.1%
if -5.4999999999999998e165 < b < -7.59999999999999991e56Initial program 65.3%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites70.4%
Taylor expanded in b around 0
Applied rewrites75.2%
if -7.59999999999999991e56 < b < -8.20000000000000061e-105Initial program 74.1%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites80.0%
Taylor expanded in y around inf
Applied rewrites71.1%
if -8.20000000000000061e-105 < b < 2.05e21Initial program 68.6%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites60.1%
Taylor expanded in z around 0
Applied rewrites46.6%
Taylor expanded in b around 0
Applied rewrites67.2%
Final simplification70.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -1.2e+130)
t_1
(if (<= b -3.5e+58)
(* (fma (- t) a (* z y)) x)
(if (<= b -8e-80)
(* (fma (- z) b (* j t)) c)
(if (<= b 1.62e-124)
(* (fma (- x) a (* j c)) t)
(if (<= b 2.6e+25) (* (fma (- i) j (* 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 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -1.2e+130) {
tmp = t_1;
} else if (b <= -3.5e+58) {
tmp = fma(-t, a, (z * y)) * x;
} else if (b <= -8e-80) {
tmp = fma(-z, b, (j * t)) * c;
} else if (b <= 1.62e-124) {
tmp = fma(-x, a, (j * c)) * t;
} else if (b <= 2.6e+25) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -1.2e+130) tmp = t_1; elseif (b <= -3.5e+58) tmp = Float64(fma(Float64(-t), a, Float64(z * y)) * x); elseif (b <= -8e-80) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (b <= 1.62e-124) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); elseif (b <= 2.6e+25) tmp = Float64(fma(Float64(-i), j, Float64(z * 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[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -1.2e+130], t$95$1, If[LessEqual[b, -3.5e+58], N[(N[((-t) * a + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, -8e-80], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 1.62e-124], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, 2.6e+25], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -1.2 \cdot 10^{+130}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3.5 \cdot 10^{+58}:\\
\;\;\;\;\mathsf{fma}\left(-t, a, z \cdot y\right) \cdot x\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;b \leq 1.62 \cdot 10^{-124}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{elif}\;b \leq 2.6 \cdot 10^{+25}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.20000000000000012e130 or 2.5999999999999998e25 < b Initial program 80.6%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6473.5
Applied rewrites73.5%
if -1.20000000000000012e130 < b < -3.4999999999999997e58Initial program 40.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6440.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6440.7
Applied rewrites40.7%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6451.2
Applied rewrites51.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6480.2
Applied rewrites80.2%
if -3.4999999999999997e58 < b < -7.99999999999999969e-80Initial program 74.7%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6461.7
Applied rewrites61.7%
if -7.99999999999999969e-80 < b < 1.62000000000000006e-124Initial program 74.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.5
Applied rewrites62.5%
if 1.62000000000000006e-124 < b < 2.5999999999999998e25Initial program 54.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- y) j (* b a)) i)))
(if (<= i -4.8e+139)
t_1
(if (<= i -0.21)
(* (fma (- z) b (* j t)) c)
(if (<= i -2e-74)
(* (fma (- x) t (* i b)) a)
(if (<= i -4.2e-107)
(* (fma (- b) c (* y x)) z)
(if (<= i 50000000000000.0) (* (fma (- x) a (* j c)) t) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-y, j, (b * a)) * i;
double tmp;
if (i <= -4.8e+139) {
tmp = t_1;
} else if (i <= -0.21) {
tmp = fma(-z, b, (j * t)) * c;
} else if (i <= -2e-74) {
tmp = fma(-x, t, (i * b)) * a;
} else if (i <= -4.2e-107) {
tmp = fma(-b, c, (y * x)) * z;
} else if (i <= 50000000000000.0) {
tmp = fma(-x, a, (j * c)) * t;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-y), j, Float64(b * a)) * i) tmp = 0.0 if (i <= -4.8e+139) tmp = t_1; elseif (i <= -0.21) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (i <= -2e-74) tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); elseif (i <= -4.2e-107) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (i <= 50000000000000.0) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -4.8e+139], t$95$1, If[LessEqual[i, -0.21], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[i, -2e-74], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[i, -4.2e-107], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[i, 50000000000000.0], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{if}\;i \leq -4.8 \cdot 10^{+139}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -0.21:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;i \leq -2 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;i \leq -4.2 \cdot 10^{-107}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;i \leq 50000000000000:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -4.80000000000000016e139 or 5e13 < i Initial program 63.3%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.6
Applied rewrites69.6%
if -4.80000000000000016e139 < i < -0.209999999999999992Initial program 69.4%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6458.7
Applied rewrites58.7%
if -0.209999999999999992 < i < -1.99999999999999992e-74Initial program 89.6%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.1
Applied rewrites74.1%
if -1.99999999999999992e-74 < i < -4.1999999999999998e-107Initial program 77.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.5
Applied rewrites62.5%
if -4.1999999999999998e-107 < i < 5e13Initial program 79.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- b) c (* y x)) z)) (t_2 (* (fma (- y) j (* b a)) i)))
(if (<= i -9e+120)
t_2
(if (<= i -980.0)
t_1
(if (<= i -2e-74)
(* (fma (- x) t (* i b)) a)
(if (<= i -4.2e-107)
t_1
(if (<= i 50000000000000.0) (* (fma (- x) a (* j c)) t) t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-b, c, (y * x)) * z;
double t_2 = fma(-y, j, (b * a)) * i;
double tmp;
if (i <= -9e+120) {
tmp = t_2;
} else if (i <= -980.0) {
tmp = t_1;
} else if (i <= -2e-74) {
tmp = fma(-x, t, (i * b)) * a;
} else if (i <= -4.2e-107) {
tmp = t_1;
} else if (i <= 50000000000000.0) {
tmp = fma(-x, a, (j * c)) * t;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-b), c, Float64(y * x)) * z) t_2 = Float64(fma(Float64(-y), j, Float64(b * a)) * i) tmp = 0.0 if (i <= -9e+120) tmp = t_2; elseif (i <= -980.0) tmp = t_1; elseif (i <= -2e-74) tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); elseif (i <= -4.2e-107) tmp = t_1; elseif (i <= 50000000000000.0) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, Block[{t$95$2 = N[(N[((-y) * j + N[(b * a), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]}, If[LessEqual[i, -9e+120], t$95$2, If[LessEqual[i, -980.0], t$95$1, If[LessEqual[i, -2e-74], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[i, -4.2e-107], t$95$1, If[LessEqual[i, 50000000000000.0], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
t_2 := \mathsf{fma}\left(-y, j, b \cdot a\right) \cdot i\\
\mathbf{if}\;i \leq -9 \cdot 10^{+120}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;i \leq -980:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -2 \cdot 10^{-74}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;i \leq -4.2 \cdot 10^{-107}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 50000000000000:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if i < -8.99999999999999953e120 or 5e13 < i Initial program 62.4%
Taylor expanded in i around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
associate-*r*N/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6468.4
Applied rewrites68.4%
if -8.99999999999999953e120 < i < -980 or -1.99999999999999992e-74 < i < -4.1999999999999998e-107Initial program 73.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6461.1
Applied rewrites61.1%
if -980 < i < -1.99999999999999992e-74Initial program 90.6%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.9
Applied rewrites71.9%
if -4.1999999999999998e-107 < i < 5e13Initial program 79.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6460.8
Applied rewrites60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -3.7e+161)
t_1
(if (<= b -8e-80)
(* (fma (- z) b (* j t)) c)
(if (<= b 1.62e-124)
(* (fma (- x) a (* j c)) t)
(if (<= b 2.6e+25) (* (fma (- i) j (* 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 = fma(-z, c, (i * a)) * b;
double tmp;
if (b <= -3.7e+161) {
tmp = t_1;
} else if (b <= -8e-80) {
tmp = fma(-z, b, (j * t)) * c;
} else if (b <= 1.62e-124) {
tmp = fma(-x, a, (j * c)) * t;
} else if (b <= 2.6e+25) {
tmp = fma(-i, j, (z * x)) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -3.7e+161) tmp = t_1; elseif (b <= -8e-80) tmp = Float64(fma(Float64(-z), b, Float64(j * t)) * c); elseif (b <= 1.62e-124) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); elseif (b <= 2.6e+25) tmp = Float64(fma(Float64(-i), j, Float64(z * 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[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -3.7e+161], t$95$1, If[LessEqual[b, -8e-80], N[(N[((-z) * b + N[(j * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 1.62e-124], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, 2.6e+25], N[(N[((-i) * j + N[(z * x), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -3.7 \cdot 10^{+161}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -8 \cdot 10^{-80}:\\
\;\;\;\;\mathsf{fma}\left(-z, b, j \cdot t\right) \cdot c\\
\mathbf{elif}\;b \leq 1.62 \cdot 10^{-124}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{elif}\;b \leq 2.6 \cdot 10^{+25}:\\
\;\;\;\;\mathsf{fma}\left(-i, j, z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -3.69999999999999979e161 or 2.5999999999999998e25 < b Initial program 80.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6475.7
Applied rewrites75.7%
if -3.69999999999999979e161 < b < -7.99999999999999969e-80Initial program 68.8%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6452.4
Applied rewrites52.4%
if -7.99999999999999969e-80 < b < 1.62000000000000006e-124Initial program 74.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6462.5
Applied rewrites62.5%
if 1.62000000000000006e-124 < b < 2.5999999999999998e25Initial program 54.3%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.9
Applied rewrites54.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- x) a (* j c)) t)))
(if (<= t -4.25e+127)
t_1
(if (<= t -2e-137)
(* (fma (- x) t (* i b)) a)
(if (<= t 1.3e-118)
(* (fma (- b) c (* y x)) z)
(if (<= t 1.62e+100) (* (fma (- i) y (* c t)) j) 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(-x, a, (j * c)) * t;
double tmp;
if (t <= -4.25e+127) {
tmp = t_1;
} else if (t <= -2e-137) {
tmp = fma(-x, t, (i * b)) * a;
} else if (t <= 1.3e-118) {
tmp = fma(-b, c, (y * x)) * z;
} else if (t <= 1.62e+100) {
tmp = fma(-i, y, (c * t)) * j;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-x), a, Float64(j * c)) * t) tmp = 0.0 if (t <= -4.25e+127) tmp = t_1; elseif (t <= -2e-137) tmp = Float64(fma(Float64(-x), t, Float64(i * b)) * a); elseif (t <= 1.3e-118) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (t <= 1.62e+100) tmp = Float64(fma(Float64(-i), y, Float64(c * t)) * j); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -4.25e+127], t$95$1, If[LessEqual[t, -2e-137], N[(N[((-x) * t + N[(i * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, 1.3e-118], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[t, 1.62e+100], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{if}\;t \leq -4.25 \cdot 10^{+127}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -2 \cdot 10^{-137}:\\
\;\;\;\;\mathsf{fma}\left(-x, t, i \cdot b\right) \cdot a\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-118}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;t \leq 1.62 \cdot 10^{+100}:\\
\;\;\;\;\mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -4.2499999999999998e127 or 1.62000000000000003e100 < t Initial program 60.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6469.2
Applied rewrites69.2%
if -4.2499999999999998e127 < t < -1.99999999999999996e-137Initial program 81.6%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6454.7
Applied rewrites54.7%
if -1.99999999999999996e-137 < t < 1.3e-118Initial program 82.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.2
Applied rewrites56.2%
if 1.3e-118 < t < 1.62000000000000003e100Initial program 69.5%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6433.5
Applied rewrites33.5%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6453.5
Applied rewrites53.5%
Final simplification59.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -2.9e+38)
(fma (fma (- x) a (* j c)) t (* (* z y) x))
(if (<= x 9.2e+86)
(fma (fma (- i) y (* c t)) j (* (* i b) a))
(fma (* j c) t (* (fma (- a) t (* z y)) x)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -2.9e+38) {
tmp = fma(fma(-x, a, (j * c)), t, ((z * y) * x));
} else if (x <= 9.2e+86) {
tmp = fma(fma(-i, y, (c * t)), j, ((i * b) * a));
} else {
tmp = fma((j * c), t, (fma(-a, t, (z * y)) * x));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -2.9e+38) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, Float64(Float64(z * y) * x)); elseif (x <= 9.2e+86) tmp = fma(fma(Float64(-i), y, Float64(c * t)), j, Float64(Float64(i * b) * a)); else tmp = fma(Float64(j * c), t, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -2.9e+38], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.2e+86], N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j + N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision], N[(N[(j * c), $MachinePrecision] * t + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.9 \cdot 10^{+38}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \left(z \cdot y\right) \cdot x\right)\\
\mathbf{elif}\;x \leq 9.2 \cdot 10^{+86}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-i, y, c \cdot t\right), j, \left(i \cdot b\right) \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot c, t, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\end{array}
\end{array}
if x < -2.90000000000000007e38Initial program 76.4%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites69.4%
Taylor expanded in z around 0
Applied rewrites38.7%
Taylor expanded in b around 0
Applied rewrites71.2%
if -2.90000000000000007e38 < x < 9.19999999999999958e86Initial program 73.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-/.f6473.2
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6473.2
Applied rewrites73.2%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
distribute-lft-inN/A
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6468.5
Applied rewrites68.5%
Taylor expanded in x around 0
Applied rewrites63.9%
lift-+.f64N/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
/-rgt-identityN/A
*-commutativeN/A
lower-fma.f6465.7
Applied rewrites65.7%
if 9.19999999999999958e86 < x Initial program 69.5%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites89.9%
Taylor expanded in b around 0
Applied rewrites72.8%
Final simplification67.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -4.5e+165)
t_1
(if (<= b 2.05e+21) (fma (fma (- x) a (* j c)) t (* (* z y) x)) 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(-z, c, (i * a)) * b;
double tmp;
if (b <= -4.5e+165) {
tmp = t_1;
} else if (b <= 2.05e+21) {
tmp = fma(fma(-x, a, (j * c)), t, ((z * y) * x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -4.5e+165) tmp = t_1; elseif (b <= 2.05e+21) tmp = fma(fma(Float64(-x), a, Float64(j * c)), t, Float64(Float64(z * y) * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -4.5e+165], t$95$1, If[LessEqual[b, 2.05e+21], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t + N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -4.5 \cdot 10^{+165}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2.05 \cdot 10^{+21}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-x, a, j \cdot c\right), t, \left(z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -4.4999999999999996e165 or 2.05e21 < b Initial program 79.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.1
Applied rewrites74.1%
if -4.4999999999999996e165 < b < 2.05e21Initial program 69.3%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites65.2%
Taylor expanded in z around 0
Applied rewrites47.2%
Taylor expanded in b around 0
Applied rewrites62.9%
Final simplification67.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- z) c (* i a)) b)))
(if (<= b -5.5e+165)
t_1
(if (<= b 3.7e+26) (fma (* j c) t (* (fma (- a) t (* z y)) x)) 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(-z, c, (i * a)) * b;
double tmp;
if (b <= -5.5e+165) {
tmp = t_1;
} else if (b <= 3.7e+26) {
tmp = fma((j * c), t, (fma(-a, t, (z * y)) * x));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-z), c, Float64(i * a)) * b) tmp = 0.0 if (b <= -5.5e+165) tmp = t_1; elseif (b <= 3.7e+26) tmp = fma(Float64(j * c), t, Float64(fma(Float64(-a), t, Float64(z * y)) * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-z) * c + N[(i * a), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -5.5e+165], t$95$1, If[LessEqual[b, 3.7e+26], N[(N[(j * c), $MachinePrecision] * t + N[(N[((-a) * t + N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-z, c, i \cdot a\right) \cdot b\\
\mathbf{if}\;b \leq -5.5 \cdot 10^{+165}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 3.7 \cdot 10^{+26}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot c, t, \mathsf{fma}\left(-a, t, z \cdot y\right) \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.4999999999999998e165 or 3.69999999999999988e26 < b Initial program 79.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6474.9
Applied rewrites74.9%
if -5.4999999999999998e165 < b < 3.69999999999999988e26Initial program 69.5%
Taylor expanded in i around 0
associate--l+N/A
sub-negN/A
+-commutativeN/A
associate-+r+N/A
*-commutativeN/A
mul-1-negN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites65.4%
Taylor expanded in b around 0
Applied rewrites60.8%
Final simplification66.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c t)) j)))
(if (<= j -17000000000.0)
t_1
(if (<= j 1.18e-48)
(* (fma (- b) c (* y x)) z)
(if (<= j 5e+127) (* (fma (- x) a (* j c)) t) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = fma(-i, y, (c * t)) * j;
double tmp;
if (j <= -17000000000.0) {
tmp = t_1;
} else if (j <= 1.18e-48) {
tmp = fma(-b, c, (y * x)) * z;
} else if (j <= 5e+127) {
tmp = fma(-x, a, (j * c)) * t;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-i), y, Float64(c * t)) * j) tmp = 0.0 if (j <= -17000000000.0) tmp = t_1; elseif (j <= 1.18e-48) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (j <= 5e+127) tmp = Float64(fma(Float64(-x), a, Float64(j * c)) * t); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -17000000000.0], t$95$1, If[LessEqual[j, 1.18e-48], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[j, 5e+127], N[(N[((-x) * a + N[(j * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{if}\;j \leq -17000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 1.18 \cdot 10^{-48}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;j \leq 5 \cdot 10^{+127}:\\
\;\;\;\;\mathsf{fma}\left(-x, a, j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.7e10 or 5.0000000000000004e127 < j Initial program 65.4%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6431.6
Applied rewrites31.6%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6464.1
Applied rewrites64.1%
if -1.7e10 < j < 1.18000000000000007e-48Initial program 74.0%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6448.0
Applied rewrites48.0%
if 1.18000000000000007e-48 < j < 5.0000000000000004e127Initial program 89.8%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6463.1
Applied rewrites63.1%
Final simplification56.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (fma (- i) y (* c t)) j)))
(if (<= j -17000000000.0)
t_1
(if (<= j 6.8e-88) (* (fma (- b) c (* y x)) 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 = fma(-i, y, (c * t)) * j;
double tmp;
if (j <= -17000000000.0) {
tmp = t_1;
} else if (j <= 6.8e-88) {
tmp = fma(-b, c, (y * x)) * z;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(fma(Float64(-i), y, Float64(c * t)) * j) tmp = 0.0 if (j <= -17000000000.0) tmp = t_1; elseif (j <= 6.8e-88) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[((-i) * y + N[(c * t), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[j, -17000000000.0], t$95$1, If[LessEqual[j, 6.8e-88], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(-i, y, c \cdot t\right) \cdot j\\
\mathbf{if}\;j \leq -17000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 6.8 \cdot 10^{-88}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.7e10 or 6.79999999999999949e-88 < j Initial program 73.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6430.0
Applied rewrites30.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6456.8
Applied rewrites56.8%
if -1.7e10 < j < 6.79999999999999949e-88Initial program 73.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.0
Applied rewrites49.0%
Final simplification53.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= j -1.05e+165)
(* (* j t) c)
(if (<= j 1e-47)
(* (fma (- b) c (* y x)) z)
(if (<= j 1.6e+88) (* (* i a) b) (* (* j c) t)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -1.05e+165) {
tmp = (j * t) * c;
} else if (j <= 1e-47) {
tmp = fma(-b, c, (y * x)) * z;
} else if (j <= 1.6e+88) {
tmp = (i * a) * b;
} else {
tmp = (j * c) * t;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -1.05e+165) tmp = Float64(Float64(j * t) * c); elseif (j <= 1e-47) tmp = Float64(fma(Float64(-b), c, Float64(y * x)) * z); elseif (j <= 1.6e+88) tmp = Float64(Float64(i * a) * b); else tmp = Float64(Float64(j * c) * t); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -1.05e+165], N[(N[(j * t), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[j, 1e-47], N[(N[((-b) * c + N[(y * x), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[j, 1.6e+88], N[(N[(i * a), $MachinePrecision] * b), $MachinePrecision], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.05 \cdot 10^{+165}:\\
\;\;\;\;\left(j \cdot t\right) \cdot c\\
\mathbf{elif}\;j \leq 10^{-47}:\\
\;\;\;\;\mathsf{fma}\left(-b, c, y \cdot x\right) \cdot z\\
\mathbf{elif}\;j \leq 1.6 \cdot 10^{+88}:\\
\;\;\;\;\left(i \cdot a\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\end{array}
\end{array}
if j < -1.05e165Initial program 57.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-/.f6457.4
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6457.4
Applied rewrites57.4%
Taylor expanded in c around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6471.6
Applied rewrites71.6%
Taylor expanded in z around 0
Applied rewrites58.4%
if -1.05e165 < j < 9.9999999999999997e-48Initial program 73.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6446.0
Applied rewrites46.0%
if 9.9999999999999997e-48 < j < 1.5999999999999999e88Initial program 88.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.9
Applied rewrites47.9%
Taylor expanded in z around 0
Applied rewrites43.9%
if 1.5999999999999999e88 < j Initial 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
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6471.2
Applied rewrites71.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6466.3
Applied rewrites66.3%
Taylor expanded in x around 0
Applied rewrites61.0%
Final simplification49.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -9e-122) (* (* i b) a) (if (<= i 2.7e+51) (* (* j c) t) (* (* (- i) 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 <= -9e-122) {
tmp = (i * b) * a;
} else if (i <= 2.7e+51) {
tmp = (j * c) * t;
} else {
tmp = (-i * y) * j;
}
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 (i <= (-9d-122)) then
tmp = (i * b) * a
else if (i <= 2.7d+51) then
tmp = (j * c) * t
else
tmp = (-i * y) * j
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 (i <= -9e-122) {
tmp = (i * b) * a;
} else if (i <= 2.7e+51) {
tmp = (j * c) * t;
} else {
tmp = (-i * y) * j;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -9e-122: tmp = (i * b) * a elif i <= 2.7e+51: tmp = (j * c) * t else: tmp = (-i * y) * j return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -9e-122) tmp = Float64(Float64(i * b) * a); elseif (i <= 2.7e+51) tmp = Float64(Float64(j * c) * t); else tmp = Float64(Float64(Float64(-i) * y) * j); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -9e-122) tmp = (i * b) * a; elseif (i <= 2.7e+51) tmp = (j * c) * t; else tmp = (-i * y) * j; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -9e-122], N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[i, 2.7e+51], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], N[(N[((-i) * y), $MachinePrecision] * j), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -9 \cdot 10^{-122}:\\
\;\;\;\;\left(i \cdot b\right) \cdot a\\
\mathbf{elif}\;i \leq 2.7 \cdot 10^{+51}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-i\right) \cdot y\right) \cdot j\\
\end{array}
\end{array}
if i < -8.99999999999999959e-122Initial program 71.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.3
Applied rewrites47.3%
Taylor expanded in x around 0
Applied rewrites39.4%
if -8.99999999999999959e-122 < i < 2.69999999999999992e51Initial program 78.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-/.f6478.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6478.7
Applied rewrites78.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6459.7
Applied rewrites59.7%
Taylor expanded in x around 0
Applied rewrites39.9%
if 2.69999999999999992e51 < i Initial program 65.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6431.0
Applied rewrites31.0%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6450.1
Applied rewrites50.1%
Taylor expanded in y around inf
Applied rewrites44.4%
Final simplification40.6%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= i -9e-122) t_1 (if (<= i 1.6e+108) (* (* j c) t) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (i * b) * a;
double tmp;
if (i <= -9e-122) {
tmp = t_1;
} else if (i <= 1.6e+108) {
tmp = (j * c) * t;
} 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 = (i * b) * a
if (i <= (-9d-122)) then
tmp = t_1
else if (i <= 1.6d+108) then
tmp = (j * c) * t
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 = (i * b) * a;
double tmp;
if (i <= -9e-122) {
tmp = t_1;
} else if (i <= 1.6e+108) {
tmp = (j * c) * t;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if i <= -9e-122: tmp = t_1 elif i <= 1.6e+108: tmp = (j * c) * t else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * a) tmp = 0.0 if (i <= -9e-122) tmp = t_1; elseif (i <= 1.6e+108) tmp = Float64(Float64(j * c) * t); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * b) * a; tmp = 0.0; if (i <= -9e-122) tmp = t_1; elseif (i <= 1.6e+108) tmp = (j * c) * t; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[i, -9e-122], t$95$1, If[LessEqual[i, 1.6e+108], N[(N[(j * c), $MachinePrecision] * t), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;i \leq -9 \cdot 10^{-122}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 1.6 \cdot 10^{+108}:\\
\;\;\;\;\left(j \cdot c\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -8.99999999999999959e-122 or 1.6e108 < i Initial program 70.4%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6449.3
Applied rewrites49.3%
Taylor expanded in x around 0
Applied rewrites41.5%
if -8.99999999999999959e-122 < i < 1.6e108Initial program 76.7%
lift-*.f64N/A
lift--.f64N/A
flip--N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
clear-numN/A
flip--N/A
lift--.f64N/A
lower-/.f6476.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6476.7
Applied rewrites76.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6457.9
Applied rewrites57.9%
Taylor expanded in x around 0
Applied rewrites38.5%
Final simplification40.2%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* i b) a))) (if (<= i -3.6e-74) t_1 (if (<= i 3.1e+105) (* (* c t) j) 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 * b) * a;
double tmp;
if (i <= -3.6e-74) {
tmp = t_1;
} else if (i <= 3.1e+105) {
tmp = (c * t) * j;
} 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 = (i * b) * a
if (i <= (-3.6d-74)) then
tmp = t_1
else if (i <= 3.1d+105) then
tmp = (c * t) * j
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 = (i * b) * a;
double tmp;
if (i <= -3.6e-74) {
tmp = t_1;
} else if (i <= 3.1e+105) {
tmp = (c * t) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (i * b) * a tmp = 0 if i <= -3.6e-74: tmp = t_1 elif i <= 3.1e+105: tmp = (c * t) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(i * b) * a) tmp = 0.0 if (i <= -3.6e-74) tmp = t_1; elseif (i <= 3.1e+105) tmp = Float64(Float64(c * t) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (i * b) * a; tmp = 0.0; if (i <= -3.6e-74) tmp = t_1; elseif (i <= 3.1e+105) tmp = (c * t) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(i * b), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[i, -3.6e-74], t$95$1, If[LessEqual[i, 3.1e+105], N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot b\right) \cdot a\\
\mathbf{if}\;i \leq -3.6 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 3.1 \cdot 10^{+105}:\\
\;\;\;\;\left(c \cdot t\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -3.6000000000000002e-74 or 3.10000000000000004e105 < i Initial program 70.0%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
remove-double-negN/A
lower-fma.f64N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6451.7
Applied rewrites51.7%
Taylor expanded in x around 0
Applied rewrites43.9%
if -3.6000000000000002e-74 < i < 3.10000000000000004e105Initial program 76.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6437.4
Applied rewrites37.4%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.9
Applied rewrites39.9%
Taylor expanded in y around 0
Applied rewrites35.9%
Final simplification39.8%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* (* c t) j))) (if (<= t -2.3e-82) t_1 (if (<= t 1.3e-96) (* (* y x) 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 (t <= -2.3e-82) {
tmp = t_1;
} else if (t <= 1.3e-96) {
tmp = (y * x) * 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 (t <= (-2.3d-82)) then
tmp = t_1
else if (t <= 1.3d-96) then
tmp = (y * x) * 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 (t <= -2.3e-82) {
tmp = t_1;
} else if (t <= 1.3e-96) {
tmp = (y * x) * 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 t <= -2.3e-82: tmp = t_1 elif t <= 1.3e-96: tmp = (y * x) * z else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(c * t) * j) tmp = 0.0 if (t <= -2.3e-82) tmp = t_1; elseif (t <= 1.3e-96) tmp = Float64(Float64(y * x) * 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 (t <= -2.3e-82) tmp = t_1; elseif (t <= 1.3e-96) tmp = (y * x) * z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(c * t), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[t, -2.3e-82], t$95$1, If[LessEqual[t, 1.3e-96], N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot t\right) \cdot j\\
\mathbf{if}\;t \leq -2.3 \cdot 10^{-82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{-96}:\\
\;\;\;\;\left(y \cdot x\right) \cdot z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.29999999999999997e-82 or 1.3000000000000001e-96 < t Initial program 67.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6430.2
Applied rewrites30.2%
Taylor expanded in j around inf
*-commutativeN/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6447.8
Applied rewrites47.8%
Taylor expanded in y around 0
Applied rewrites38.1%
if -2.29999999999999997e-82 < t < 1.3000000000000001e-96Initial program 84.1%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6452.3
Applied rewrites52.3%
Taylor expanded in x around inf
Applied rewrites34.5%
Final simplification36.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -4.2e-277) (* (* z x) y) (* (* z y) x)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -4.2e-277) {
tmp = (z * x) * y;
} else {
tmp = (z * y) * x;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-4.2d-277)) then
tmp = (z * x) * y
else
tmp = (z * y) * x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -4.2e-277) {
tmp = (z * x) * y;
} else {
tmp = (z * y) * x;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -4.2e-277: tmp = (z * x) * y else: tmp = (z * y) * x return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -4.2e-277) tmp = Float64(Float64(z * x) * y); else tmp = Float64(Float64(z * y) * x); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -4.2e-277) tmp = (z * x) * y; else tmp = (z * y) * x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -4.2e-277], N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision], N[(N[(z * y), $MachinePrecision] * x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4.2 \cdot 10^{-277}:\\
\;\;\;\;\left(z \cdot x\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot y\right) \cdot x\\
\end{array}
\end{array}
if i < -4.1999999999999999e-277Initial program 71.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6439.8
Applied rewrites39.8%
Taylor expanded in x around inf
Applied rewrites20.3%
Applied rewrites23.6%
if -4.1999999999999999e-277 < i Initial program 74.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6436.2
Applied rewrites36.2%
Taylor expanded in x around inf
Applied rewrites21.5%
(FPCore (x y z t a b c i j) :precision binary64 (* (* y x) z))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (y * x) * z;
}
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 = (y * x) * z
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 (y * x) * z;
}
def code(x, y, z, t, a, b, c, i, j): return (y * x) * z
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(y * x) * z) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (y * x) * z; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(y * x), $MachinePrecision] * z), $MachinePrecision]
\begin{array}{l}
\\
\left(y \cdot x\right) \cdot z
\end{array}
Initial program 73.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6438.1
Applied rewrites38.1%
Taylor expanded in x around inf
Applied rewrites21.6%
Final simplification21.6%
(FPCore (x y z t a b c i j) :precision binary64 (* (* z x) y))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return (z * x) * 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 = (z * x) * 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 (z * x) * y;
}
def code(x, y, z, t, a, b, c, i, j): return (z * x) * y
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(z * x) * y) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = (z * x) * y; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(z * x), $MachinePrecision] * y), $MachinePrecision]
\begin{array}{l}
\\
\left(z \cdot x\right) \cdot y
\end{array}
Initial program 73.3%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6438.1
Applied rewrites38.1%
Taylor expanded in x around inf
Applied rewrites20.9%
Applied rewrites20.4%
(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 2024298
(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)))))