
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(* (- (* x j) (* z k)) (- (* y0 b) (* y1 i))))
(* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a))))
(* (- (* t j) (* y k)) (- (* y4 b) (* y5 i))))
(* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(Float64(y0 * b) - Float64(y1 * i)))) + Float64(Float64(Float64(x * y2) - Float64(z * y3)) * Float64(Float64(y0 * c) - Float64(y1 * a)))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * Float64(Float64(y4 * b) - Float64(y5 * i)))) - Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(y4 * c) - Float64(y5 * a)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(x \cdot j - z \cdot k\right) \cdot \left(y0 \cdot b - y1 \cdot i\right)\right) + \left(x \cdot y2 - z \cdot y3\right) \cdot \left(y0 \cdot c - y1 \cdot a\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot \left(y4 \cdot b - y5 \cdot i\right)\right) - \left(t \cdot y2 - y \cdot y3\right) \cdot \left(y4 \cdot c - y5 \cdot a\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 33 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(* (- (* x j) (* z k)) (- (* y0 b) (* y1 i))))
(* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a))))
(* (- (* t j) (* y k)) (- (* y4 b) (* y5 i))))
(* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)))
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(Float64(y0 * b) - Float64(y1 * i)))) + Float64(Float64(Float64(x * y2) - Float64(z * y3)) * Float64(Float64(y0 * c) - Float64(y1 * a)))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * Float64(Float64(y4 * b) - Float64(y5 * i)))) - Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(y4 * c) - Float64(y5 * a)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - (((x * j) - (z * k)) * ((y0 * b) - (y1 * i)))) + (((x * y2) - (z * y3)) * ((y0 * c) - (y1 * a)))) + (((t * j) - (y * k)) * ((y4 * b) - (y5 * i)))) - (((t * y2) - (y * y3)) * ((y4 * c) - (y5 * a)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(x \cdot j - z \cdot k\right) \cdot \left(y0 \cdot b - y1 \cdot i\right)\right) + \left(x \cdot y2 - z \cdot y3\right) \cdot \left(y0 \cdot c - y1 \cdot a\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot \left(y4 \cdot b - y5 \cdot i\right)\right) - \left(t \cdot y2 - y \cdot y3\right) \cdot \left(y4 \cdot c - y5 \cdot a\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)
\end{array}
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* y5 i) (* y4 b))
y
(fma (- (* y4 y1) (* y5 y0)) y2 (* (- (* y0 b) (* y1 i)) z)))
k)))
(if (<= t -4.9e+147)
(* (* (fma (- c) y2 (* j b)) t) y4)
(if (<= t -2.1e-71)
t_1
(if (<= t -7e-116)
(* (* (fma j y0 (* (- a) y)) y5) y3)
(if (<= t 3e-109)
t_1
(if (<= t 0.15)
(*
(fma
(- (* j t) (* k y))
b
(fma (- (* y2 k) (* y3 j)) y1 (* (- (* y3 y) (* y2 t)) c)))
y4)
(if (<= t 4.3e+79)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(if (<= t 1.08e+206)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
(* (* (- (* y0 k) (* a t)) z) b))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((y5 * i) - (y4 * b)), y, fma(((y4 * y1) - (y5 * y0)), y2, (((y0 * b) - (y1 * i)) * z))) * k;
double tmp;
if (t <= -4.9e+147) {
tmp = (fma(-c, y2, (j * b)) * t) * y4;
} else if (t <= -2.1e-71) {
tmp = t_1;
} else if (t <= -7e-116) {
tmp = (fma(j, y0, (-a * y)) * y5) * y3;
} else if (t <= 3e-109) {
tmp = t_1;
} else if (t <= 0.15) {
tmp = fma(((j * t) - (k * y)), b, fma(((y2 * k) - (y3 * j)), y1, (((y3 * y) - (y2 * t)) * c))) * y4;
} else if (t <= 4.3e+79) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else if (t <= 1.08e+206) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else {
tmp = (((y0 * k) - (a * t)) * z) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(y5 * i) - Float64(y4 * b)), y, fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), y2, Float64(Float64(Float64(y0 * b) - Float64(y1 * i)) * z))) * k) tmp = 0.0 if (t <= -4.9e+147) tmp = Float64(Float64(fma(Float64(-c), y2, Float64(j * b)) * t) * y4); elseif (t <= -2.1e-71) tmp = t_1; elseif (t <= -7e-116) tmp = Float64(Float64(fma(j, y0, Float64(Float64(-a) * y)) * y5) * y3); elseif (t <= 3e-109) tmp = t_1; elseif (t <= 0.15) tmp = Float64(fma(Float64(Float64(j * t) - Float64(k * y)), b, fma(Float64(Float64(y2 * k) - Float64(y3 * j)), y1, Float64(Float64(Float64(y3 * y) - Float64(y2 * t)) * c))) * y4); elseif (t <= 4.3e+79) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); elseif (t <= 1.08e+206) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); else tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(y5 * i), $MachinePrecision] - N[(y4 * b), $MachinePrecision]), $MachinePrecision] * y + N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t, -4.9e+147], N[(N[(N[((-c) * y2 + N[(j * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[t, -2.1e-71], t$95$1, If[LessEqual[t, -7e-116], N[(N[(N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, 3e-109], t$95$1, If[LessEqual[t, 0.15], N[(N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * b + N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(N[(y3 * y), $MachinePrecision] - N[(y2 * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[t, 4.3e+79], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, 1.08e+206], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y5 \cdot i - y4 \cdot b, y, \mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, y2, \left(y0 \cdot b - y1 \cdot i\right) \cdot z\right)\right) \cdot k\\
\mathbf{if}\;t \leq -4.9 \cdot 10^{+147}:\\
\;\;\;\;\left(\mathsf{fma}\left(-c, y2, j \cdot b\right) \cdot t\right) \cdot y4\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7 \cdot 10^{-116}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right) \cdot y5\right) \cdot y3\\
\mathbf{elif}\;t \leq 3 \cdot 10^{-109}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 0.15:\\
\;\;\;\;\mathsf{fma}\left(j \cdot t - k \cdot y, b, \mathsf{fma}\left(y2 \cdot k - y3 \cdot j, y1, \left(y3 \cdot y - y2 \cdot t\right) \cdot c\right)\right) \cdot y4\\
\mathbf{elif}\;t \leq 4.3 \cdot 10^{+79}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{elif}\;t \leq 1.08 \cdot 10^{+206}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\end{array}
\end{array}
if t < -4.8999999999999998e147Initial program 29.2%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in y1 around inf
Applied rewrites17.2%
Taylor expanded in t around inf
Applied rewrites59.0%
if -4.8999999999999998e147 < t < -2.1000000000000001e-71 or -6.99999999999999968e-116 < t < 3.00000000000000021e-109Initial program 35.9%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.4%
if -2.1000000000000001e-71 < t < -6.99999999999999968e-116Initial program 14.8%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites64.2%
Taylor expanded in z around inf
Applied rewrites36.9%
Taylor expanded in y5 around inf
Applied rewrites77.3%
if 3.00000000000000021e-109 < t < 0.149999999999999994Initial program 42.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.3%
if 0.149999999999999994 < t < 4.3000000000000003e79Initial program 21.4%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.0%
Taylor expanded in z around inf
Applied rewrites43.6%
Taylor expanded in y0 around inf
Applied rewrites72.2%
if 4.3000000000000003e79 < t < 1.08000000000000005e206Initial program 24.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites64.3%
if 1.08000000000000005e206 < t Initial program 20.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.7%
Taylor expanded in z around inf
Applied rewrites75.3%
Final simplification61.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<=
(-
(-
(+
(* (- (* y4 b) (* y5 i)) (- (* j t) (* k y)))
(-
(-
(* (- (* y1 i) (* y0 b)) (- (* j x) (* k z)))
(* (- (* t z) (* y x)) (- (* b a) (* i c))))
(* (- (* y2 x) (* y3 z)) (- (* y1 a) (* y0 c)))))
(* (- (* y5 a) (* y4 c)) (- (* y3 y) (* y2 t))))
(* (- (* y3 j) (* y2 k)) (- (* y4 y1) (* y5 y0))))
INFINITY)
(fma
(fma (- y3) j (* y2 k))
(fma (- y0) y5 (* y4 y1))
(fma
(- (fma (- a) y5 (* y4 c)))
(fma (- y3) y (* y2 t))
(fma
(fma (- i) y5 (* y4 b))
(fma (- k) y (* j t))
(fma
(fma (- a) y1 (* y0 c))
(fma (- y3) z (* y2 x))
(fma
(- (fma (- i) y1 (* y0 b)))
(fma (- k) z (* j x))
(* (fma (- t) z (* y x)) (fma (- i) c (* b a))))))))
(*
(fma
(- i)
(* y1 z)
(fma
y
(fma (- b) y4 (* y5 i))
(fma (* y2 y1) y4 (* (fma b z (* (- y2) y5)) y0))))
k)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (((((((y4 * b) - (y5 * i)) * ((j * t) - (k * y))) + (((((y1 * i) - (y0 * b)) * ((j * x) - (k * z))) - (((t * z) - (y * x)) * ((b * a) - (i * c)))) - (((y2 * x) - (y3 * z)) * ((y1 * a) - (y0 * c))))) - (((y5 * a) - (y4 * c)) * ((y3 * y) - (y2 * t)))) - (((y3 * j) - (y2 * k)) * ((y4 * y1) - (y5 * y0)))) <= ((double) INFINITY)) {
tmp = fma(fma(-y3, j, (y2 * k)), fma(-y0, y5, (y4 * y1)), fma(-fma(-a, y5, (y4 * c)), fma(-y3, y, (y2 * t)), fma(fma(-i, y5, (y4 * b)), fma(-k, y, (j * t)), fma(fma(-a, y1, (y0 * c)), fma(-y3, z, (y2 * x)), fma(-fma(-i, y1, (y0 * b)), fma(-k, z, (j * x)), (fma(-t, z, (y * x)) * fma(-i, c, (b * a))))))));
} else {
tmp = fma(-i, (y1 * z), fma(y, fma(-b, y4, (y5 * i)), fma((y2 * y1), y4, (fma(b, z, (-y2 * y5)) * y0)))) * k;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (Float64(Float64(Float64(Float64(Float64(Float64(y4 * b) - Float64(y5 * i)) * Float64(Float64(j * t) - Float64(k * y))) + Float64(Float64(Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * Float64(Float64(j * x) - Float64(k * z))) - Float64(Float64(Float64(t * z) - Float64(y * x)) * Float64(Float64(b * a) - Float64(i * c)))) - Float64(Float64(Float64(y2 * x) - Float64(y3 * z)) * Float64(Float64(y1 * a) - Float64(y0 * c))))) - Float64(Float64(Float64(y5 * a) - Float64(y4 * c)) * Float64(Float64(y3 * y) - Float64(y2 * t)))) - Float64(Float64(Float64(y3 * j) - Float64(y2 * k)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))) <= Inf) tmp = fma(fma(Float64(-y3), j, Float64(y2 * k)), fma(Float64(-y0), y5, Float64(y4 * y1)), fma(Float64(-fma(Float64(-a), y5, Float64(y4 * c))), fma(Float64(-y3), y, Float64(y2 * t)), fma(fma(Float64(-i), y5, Float64(y4 * b)), fma(Float64(-k), y, Float64(j * t)), fma(fma(Float64(-a), y1, Float64(y0 * c)), fma(Float64(-y3), z, Float64(y2 * x)), fma(Float64(-fma(Float64(-i), y1, Float64(y0 * b))), fma(Float64(-k), z, Float64(j * x)), Float64(fma(Float64(-t), z, Float64(y * x)) * fma(Float64(-i), c, Float64(b * a)))))))); else tmp = Float64(fma(Float64(-i), Float64(y1 * z), fma(y, fma(Float64(-b), y4, Float64(y5 * i)), fma(Float64(y2 * y1), y4, Float64(fma(b, z, Float64(Float64(-y2) * y5)) * y0)))) * k); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[N[(N[(N[(N[(N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision] * N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * N[(N[(j * x), $MachinePrecision] - N[(k * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(t * z), $MachinePrecision] - N[(y * x), $MachinePrecision]), $MachinePrecision] * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(y2 * x), $MachinePrecision] - N[(y3 * z), $MachinePrecision]), $MachinePrecision] * N[(N[(y1 * a), $MachinePrecision] - N[(y0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(y5 * a), $MachinePrecision] - N[(y4 * c), $MachinePrecision]), $MachinePrecision] * N[(N[(y3 * y), $MachinePrecision] - N[(y2 * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(y3 * j), $MachinePrecision] - N[(y2 * k), $MachinePrecision]), $MachinePrecision] * N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[((-y3) * j + N[(y2 * k), $MachinePrecision]), $MachinePrecision] * N[((-y0) * y5 + N[(y4 * y1), $MachinePrecision]), $MachinePrecision] + N[((-N[((-a) * y5 + N[(y4 * c), $MachinePrecision]), $MachinePrecision]) * N[((-y3) * y + N[(y2 * t), $MachinePrecision]), $MachinePrecision] + N[(N[((-i) * y5 + N[(y4 * b), $MachinePrecision]), $MachinePrecision] * N[((-k) * y + N[(j * t), $MachinePrecision]), $MachinePrecision] + N[(N[((-a) * y1 + N[(y0 * c), $MachinePrecision]), $MachinePrecision] * N[((-y3) * z + N[(y2 * x), $MachinePrecision]), $MachinePrecision] + N[((-N[((-i) * y1 + N[(y0 * b), $MachinePrecision]), $MachinePrecision]) * N[((-k) * z + N[(j * x), $MachinePrecision]), $MachinePrecision] + N[(N[((-t) * z + N[(y * x), $MachinePrecision]), $MachinePrecision] * N[((-i) * c + N[(b * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[((-i) * N[(y1 * z), $MachinePrecision] + N[(y * N[((-b) * y4 + N[(y5 * i), $MachinePrecision]), $MachinePrecision] + N[(N[(y2 * y1), $MachinePrecision] * y4 + N[(N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(\left(\left(y4 \cdot b - y5 \cdot i\right) \cdot \left(j \cdot t - k \cdot y\right) + \left(\left(\left(y1 \cdot i - y0 \cdot b\right) \cdot \left(j \cdot x - k \cdot z\right) - \left(t \cdot z - y \cdot x\right) \cdot \left(b \cdot a - i \cdot c\right)\right) - \left(y2 \cdot x - y3 \cdot z\right) \cdot \left(y1 \cdot a - y0 \cdot c\right)\right)\right) - \left(y5 \cdot a - y4 \cdot c\right) \cdot \left(y3 \cdot y - y2 \cdot t\right)\right) - \left(y3 \cdot j - y2 \cdot k\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right) \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(-y3, j, y2 \cdot k\right), \mathsf{fma}\left(-y0, y5, y4 \cdot y1\right), \mathsf{fma}\left(-\mathsf{fma}\left(-a, y5, y4 \cdot c\right), \mathsf{fma}\left(-y3, y, y2 \cdot t\right), \mathsf{fma}\left(\mathsf{fma}\left(-i, y5, y4 \cdot b\right), \mathsf{fma}\left(-k, y, j \cdot t\right), \mathsf{fma}\left(\mathsf{fma}\left(-a, y1, y0 \cdot c\right), \mathsf{fma}\left(-y3, z, y2 \cdot x\right), \mathsf{fma}\left(-\mathsf{fma}\left(-i, y1, y0 \cdot b\right), \mathsf{fma}\left(-k, z, j \cdot x\right), \mathsf{fma}\left(-t, z, y \cdot x\right) \cdot \mathsf{fma}\left(-i, c, b \cdot a\right)\right)\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-i, y1 \cdot z, \mathsf{fma}\left(y, \mathsf{fma}\left(-b, y4, y5 \cdot i\right), \mathsf{fma}\left(y2 \cdot y1, y4, \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right) \cdot y0\right)\right)\right) \cdot k\\
\end{array}
\end{array}
if (+.f64 (-.f64 (+.f64 (+.f64 (-.f64 (*.f64 (-.f64 (*.f64 x y) (*.f64 z t)) (-.f64 (*.f64 a b) (*.f64 c i))) (*.f64 (-.f64 (*.f64 x j) (*.f64 z k)) (-.f64 (*.f64 y0 b) (*.f64 y1 i)))) (*.f64 (-.f64 (*.f64 x y2) (*.f64 z y3)) (-.f64 (*.f64 y0 c) (*.f64 y1 a)))) (*.f64 (-.f64 (*.f64 t j) (*.f64 y k)) (-.f64 (*.f64 y4 b) (*.f64 y5 i)))) (*.f64 (-.f64 (*.f64 t y2) (*.f64 y y3)) (-.f64 (*.f64 y4 c) (*.f64 y5 a)))) (*.f64 (-.f64 (*.f64 k y2) (*.f64 j y3)) (-.f64 (*.f64 y4 y1) (*.f64 y5 y0)))) < +inf.0Initial program 93.2%
Applied rewrites93.2%
if +inf.0 < (+.f64 (-.f64 (+.f64 (+.f64 (-.f64 (*.f64 (-.f64 (*.f64 x y) (*.f64 z t)) (-.f64 (*.f64 a b) (*.f64 c i))) (*.f64 (-.f64 (*.f64 x j) (*.f64 z k)) (-.f64 (*.f64 y0 b) (*.f64 y1 i)))) (*.f64 (-.f64 (*.f64 x y2) (*.f64 z y3)) (-.f64 (*.f64 y0 c) (*.f64 y1 a)))) (*.f64 (-.f64 (*.f64 t j) (*.f64 y k)) (-.f64 (*.f64 y4 b) (*.f64 y5 i)))) (*.f64 (-.f64 (*.f64 t y2) (*.f64 y y3)) (-.f64 (*.f64 y4 c) (*.f64 y5 a)))) (*.f64 (-.f64 (*.f64 k y2) (*.f64 j y3)) (-.f64 (*.f64 y4 y1) (*.f64 y5 y0)))) Initial program 0.0%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites38.6%
Taylor expanded in y0 around 0
Applied rewrites43.3%
Final simplification60.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* y5 i) (* y4 b))
y
(fma (- (* y4 y1) (* y5 y0)) y2 (* (- (* y0 b) (* y1 i)) z)))
k)))
(if (<= t -4.9e+147)
(* (* (fma (- c) y2 (* j b)) t) y4)
(if (<= t -2.1e-71)
t_1
(if (<= t -7e-116)
(* (* (fma j y0 (* (- a) y)) y5) y3)
(if (<= t 1e-116)
t_1
(if (<= t 0.12)
(* (+ (* (fma c y0 (* (- a) y1)) y2) (* (* j i) y1)) x)
(if (<= t 4.3e+79)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(if (<= t 1.08e+206)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
(* (* (- (* y0 k) (* a t)) z) b))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((y5 * i) - (y4 * b)), y, fma(((y4 * y1) - (y5 * y0)), y2, (((y0 * b) - (y1 * i)) * z))) * k;
double tmp;
if (t <= -4.9e+147) {
tmp = (fma(-c, y2, (j * b)) * t) * y4;
} else if (t <= -2.1e-71) {
tmp = t_1;
} else if (t <= -7e-116) {
tmp = (fma(j, y0, (-a * y)) * y5) * y3;
} else if (t <= 1e-116) {
tmp = t_1;
} else if (t <= 0.12) {
tmp = ((fma(c, y0, (-a * y1)) * y2) + ((j * i) * y1)) * x;
} else if (t <= 4.3e+79) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else if (t <= 1.08e+206) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else {
tmp = (((y0 * k) - (a * t)) * z) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(y5 * i) - Float64(y4 * b)), y, fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), y2, Float64(Float64(Float64(y0 * b) - Float64(y1 * i)) * z))) * k) tmp = 0.0 if (t <= -4.9e+147) tmp = Float64(Float64(fma(Float64(-c), y2, Float64(j * b)) * t) * y4); elseif (t <= -2.1e-71) tmp = t_1; elseif (t <= -7e-116) tmp = Float64(Float64(fma(j, y0, Float64(Float64(-a) * y)) * y5) * y3); elseif (t <= 1e-116) tmp = t_1; elseif (t <= 0.12) tmp = Float64(Float64(Float64(fma(c, y0, Float64(Float64(-a) * y1)) * y2) + Float64(Float64(j * i) * y1)) * x); elseif (t <= 4.3e+79) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); elseif (t <= 1.08e+206) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); else tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(y5 * i), $MachinePrecision] - N[(y4 * b), $MachinePrecision]), $MachinePrecision] * y + N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t, -4.9e+147], N[(N[(N[((-c) * y2 + N[(j * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[t, -2.1e-71], t$95$1, If[LessEqual[t, -7e-116], N[(N[(N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, 1e-116], t$95$1, If[LessEqual[t, 0.12], N[(N[(N[(N[(c * y0 + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] + N[(N[(j * i), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[t, 4.3e+79], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, 1.08e+206], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y5 \cdot i - y4 \cdot b, y, \mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, y2, \left(y0 \cdot b - y1 \cdot i\right) \cdot z\right)\right) \cdot k\\
\mathbf{if}\;t \leq -4.9 \cdot 10^{+147}:\\
\;\;\;\;\left(\mathsf{fma}\left(-c, y2, j \cdot b\right) \cdot t\right) \cdot y4\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7 \cdot 10^{-116}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right) \cdot y5\right) \cdot y3\\
\mathbf{elif}\;t \leq 10^{-116}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 0.12:\\
\;\;\;\;\left(\mathsf{fma}\left(c, y0, \left(-a\right) \cdot y1\right) \cdot y2 + \left(j \cdot i\right) \cdot y1\right) \cdot x\\
\mathbf{elif}\;t \leq 4.3 \cdot 10^{+79}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{elif}\;t \leq 1.08 \cdot 10^{+206}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\end{array}
\end{array}
if t < -4.8999999999999998e147Initial program 29.2%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in y1 around inf
Applied rewrites17.2%
Taylor expanded in t around inf
Applied rewrites59.0%
if -4.8999999999999998e147 < t < -2.1000000000000001e-71 or -6.99999999999999968e-116 < t < 9.9999999999999999e-117Initial program 36.8%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.0%
if -2.1000000000000001e-71 < t < -6.99999999999999968e-116Initial program 14.8%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites64.2%
Taylor expanded in z around inf
Applied rewrites36.9%
Taylor expanded in y5 around inf
Applied rewrites77.3%
if 9.9999999999999999e-117 < t < 0.12Initial program 38.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.6%
Taylor expanded in y around 0
Applied rewrites45.8%
Taylor expanded in b around 0
Applied rewrites52.3%
if 0.12 < t < 4.3000000000000003e79Initial program 21.4%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.0%
Taylor expanded in z around inf
Applied rewrites43.6%
Taylor expanded in y0 around inf
Applied rewrites72.2%
if 4.3000000000000003e79 < t < 1.08000000000000005e206Initial program 24.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites64.3%
if 1.08000000000000005e206 < t Initial program 20.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.7%
Taylor expanded in z around inf
Applied rewrites75.3%
Final simplification61.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma j t (* (- y) k)) b) y4)))
(if (<= b -7.6e+260)
t_1
(if (<= b -1.36e+194)
(*
(fma
(* y0 c)
y2
(fma (* (- a) y2) y1 (* (fma (- i) y1 (* y0 b)) (- j))))
x)
(if (<= b -1.25e+108)
(* (fma c i (* (- b) a)) (* t z))
(if (<= b -1.25e-260)
(*
(fma (fma y0 c (* (- a) y1)) y2 (fma (* (- y) i) c (* (* y1 j) i)))
x)
(if (<= b 5e-297)
(*
(fma
(- (* y3 z) (* y2 x))
a
(fma (- (* y2 k) (* y3 j)) y4 (* (- (* j x) (* k z)) i)))
y1)
(if (<= b 1.65e-37)
(* (* (fma k y1 (* (- c) t)) y2) y4)
(if (<= b 5.5e+153)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
t_1)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(j, t, (-y * k)) * b) * y4;
double tmp;
if (b <= -7.6e+260) {
tmp = t_1;
} else if (b <= -1.36e+194) {
tmp = fma((y0 * c), y2, fma((-a * y2), y1, (fma(-i, y1, (y0 * b)) * -j))) * x;
} else if (b <= -1.25e+108) {
tmp = fma(c, i, (-b * a)) * (t * z);
} else if (b <= -1.25e-260) {
tmp = fma(fma(y0, c, (-a * y1)), y2, fma((-y * i), c, ((y1 * j) * i))) * x;
} else if (b <= 5e-297) {
tmp = fma(((y3 * z) - (y2 * x)), a, fma(((y2 * k) - (y3 * j)), y4, (((j * x) - (k * z)) * i))) * y1;
} else if (b <= 1.65e-37) {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
} else if (b <= 5.5e+153) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4) tmp = 0.0 if (b <= -7.6e+260) tmp = t_1; elseif (b <= -1.36e+194) tmp = Float64(fma(Float64(y0 * c), y2, fma(Float64(Float64(-a) * y2), y1, Float64(fma(Float64(-i), y1, Float64(y0 * b)) * Float64(-j)))) * x); elseif (b <= -1.25e+108) tmp = Float64(fma(c, i, Float64(Float64(-b) * a)) * Float64(t * z)); elseif (b <= -1.25e-260) tmp = Float64(fma(fma(y0, c, Float64(Float64(-a) * y1)), y2, fma(Float64(Float64(-y) * i), c, Float64(Float64(y1 * j) * i))) * x); elseif (b <= 5e-297) tmp = Float64(fma(Float64(Float64(y3 * z) - Float64(y2 * x)), a, fma(Float64(Float64(y2 * k) - Float64(y3 * j)), y4, Float64(Float64(Float64(j * x) - Float64(k * z)) * i))) * y1); elseif (b <= 1.65e-37) tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); elseif (b <= 5.5e+153) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision]}, If[LessEqual[b, -7.6e+260], t$95$1, If[LessEqual[b, -1.36e+194], N[(N[(N[(y0 * c), $MachinePrecision] * y2 + N[(N[((-a) * y2), $MachinePrecision] * y1 + N[(N[((-i) * y1 + N[(y0 * b), $MachinePrecision]), $MachinePrecision] * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, -1.25e+108], N[(N[(c * i + N[((-b) * a), $MachinePrecision]), $MachinePrecision] * N[(t * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.25e-260], N[(N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[((-y) * i), $MachinePrecision] * c + N[(N[(y1 * j), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 5e-297], N[(N[(N[(N[(y3 * z), $MachinePrecision] - N[(y2 * x), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * y4 + N[(N[(N[(j * x), $MachinePrecision] - N[(k * z), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y1), $MachinePrecision], If[LessEqual[b, 1.65e-37], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[b, 5.5e+153], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{if}\;b \leq -7.6 \cdot 10^{+260}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.36 \cdot 10^{+194}:\\
\;\;\;\;\mathsf{fma}\left(y0 \cdot c, y2, \mathsf{fma}\left(\left(-a\right) \cdot y2, y1, \mathsf{fma}\left(-i, y1, y0 \cdot b\right) \cdot \left(-j\right)\right)\right) \cdot x\\
\mathbf{elif}\;b \leq -1.25 \cdot 10^{+108}:\\
\;\;\;\;\mathsf{fma}\left(c, i, \left(-b\right) \cdot a\right) \cdot \left(t \cdot z\right)\\
\mathbf{elif}\;b \leq -1.25 \cdot 10^{-260}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(\left(-y\right) \cdot i, c, \left(y1 \cdot j\right) \cdot i\right)\right) \cdot x\\
\mathbf{elif}\;b \leq 5 \cdot 10^{-297}:\\
\;\;\;\;\mathsf{fma}\left(y3 \cdot z - y2 \cdot x, a, \mathsf{fma}\left(y2 \cdot k - y3 \cdot j, y4, \left(j \cdot x - k \cdot z\right) \cdot i\right)\right) \cdot y1\\
\mathbf{elif}\;b \leq 1.65 \cdot 10^{-37}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{+153}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -7.5999999999999995e260 or 5.5000000000000003e153 < b Initial program 26.9%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.3%
Taylor expanded in b around inf
Applied rewrites71.5%
if -7.5999999999999995e260 < b < -1.35999999999999994e194Initial program 50.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites75.0%
Taylor expanded in y around 0
Applied rewrites66.8%
Applied rewrites91.8%
if -1.35999999999999994e194 < b < -1.24999999999999998e108Initial program 27.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.9%
Taylor expanded in j around inf
Applied rewrites27.6%
Taylor expanded in z around inf
Applied rewrites73.8%
if -1.24999999999999998e108 < b < -1.2500000000000001e-260Initial program 35.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.1%
Taylor expanded in b around 0
Applied rewrites49.0%
Applied rewrites50.3%
if -1.2500000000000001e-260 < b < 5e-297Initial program 37.9%
Taylor expanded in y1 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.7%
if 5e-297 < b < 1.64999999999999991e-37Initial program 27.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.7%
Taylor expanded in y1 around inf
Applied rewrites36.3%
Taylor expanded in k around 0
Applied rewrites17.4%
Taylor expanded in y2 around inf
Applied rewrites49.8%
if 1.64999999999999991e-37 < b < 5.5000000000000003e153Initial program 27.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.5%
Final simplification58.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* y5 i) (* y4 b))
y
(fma (- (* y4 y1) (* y5 y0)) y2 (* (- (* y0 b) (* y1 i)) z)))
k)))
(if (<= t -4.9e+147)
(* (* (fma (- c) y2 (* j b)) t) y4)
(if (<= t -2.1e-71)
t_1
(if (<= t -7e-116)
(* (* (fma j y0 (* (- a) y)) y5) y3)
(if (<= t 9.6e-128)
t_1
(if (<= t 7.2e+89)
(*
(fma
(- (* y x) (* t z))
a
(fma (- (* j t) (* k y)) y4 (* (- (* k z) (* j x)) y0)))
b)
(if (<= t 1.08e+206)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
(* (* (- (* y0 k) (* a t)) z) b)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((y5 * i) - (y4 * b)), y, fma(((y4 * y1) - (y5 * y0)), y2, (((y0 * b) - (y1 * i)) * z))) * k;
double tmp;
if (t <= -4.9e+147) {
tmp = (fma(-c, y2, (j * b)) * t) * y4;
} else if (t <= -2.1e-71) {
tmp = t_1;
} else if (t <= -7e-116) {
tmp = (fma(j, y0, (-a * y)) * y5) * y3;
} else if (t <= 9.6e-128) {
tmp = t_1;
} else if (t <= 7.2e+89) {
tmp = fma(((y * x) - (t * z)), a, fma(((j * t) - (k * y)), y4, (((k * z) - (j * x)) * y0))) * b;
} else if (t <= 1.08e+206) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else {
tmp = (((y0 * k) - (a * t)) * z) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(y5 * i) - Float64(y4 * b)), y, fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), y2, Float64(Float64(Float64(y0 * b) - Float64(y1 * i)) * z))) * k) tmp = 0.0 if (t <= -4.9e+147) tmp = Float64(Float64(fma(Float64(-c), y2, Float64(j * b)) * t) * y4); elseif (t <= -2.1e-71) tmp = t_1; elseif (t <= -7e-116) tmp = Float64(Float64(fma(j, y0, Float64(Float64(-a) * y)) * y5) * y3); elseif (t <= 9.6e-128) tmp = t_1; elseif (t <= 7.2e+89) tmp = Float64(fma(Float64(Float64(y * x) - Float64(t * z)), a, fma(Float64(Float64(j * t) - Float64(k * y)), y4, Float64(Float64(Float64(k * z) - Float64(j * x)) * y0))) * b); elseif (t <= 1.08e+206) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); else tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(y5 * i), $MachinePrecision] - N[(y4 * b), $MachinePrecision]), $MachinePrecision] * y + N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[t, -4.9e+147], N[(N[(N[((-c) * y2 + N[(j * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[t, -2.1e-71], t$95$1, If[LessEqual[t, -7e-116], N[(N[(N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, 9.6e-128], t$95$1, If[LessEqual[t, 7.2e+89], N[(N[(N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * y4 + N[(N[(N[(k * z), $MachinePrecision] - N[(j * x), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[t, 1.08e+206], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y5 \cdot i - y4 \cdot b, y, \mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, y2, \left(y0 \cdot b - y1 \cdot i\right) \cdot z\right)\right) \cdot k\\
\mathbf{if}\;t \leq -4.9 \cdot 10^{+147}:\\
\;\;\;\;\left(\mathsf{fma}\left(-c, y2, j \cdot b\right) \cdot t\right) \cdot y4\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{-71}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -7 \cdot 10^{-116}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right) \cdot y5\right) \cdot y3\\
\mathbf{elif}\;t \leq 9.6 \cdot 10^{-128}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 7.2 \cdot 10^{+89}:\\
\;\;\;\;\mathsf{fma}\left(y \cdot x - t \cdot z, a, \mathsf{fma}\left(j \cdot t - k \cdot y, y4, \left(k \cdot z - j \cdot x\right) \cdot y0\right)\right) \cdot b\\
\mathbf{elif}\;t \leq 1.08 \cdot 10^{+206}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\end{array}
\end{array}
if t < -4.8999999999999998e147Initial program 29.2%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in y1 around inf
Applied rewrites17.2%
Taylor expanded in t around inf
Applied rewrites59.0%
if -4.8999999999999998e147 < t < -2.1000000000000001e-71 or -6.99999999999999968e-116 < t < 9.5999999999999993e-128Initial program 37.0%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.4%
if -2.1000000000000001e-71 < t < -6.99999999999999968e-116Initial program 14.8%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites64.2%
Taylor expanded in z around inf
Applied rewrites36.9%
Taylor expanded in y5 around inf
Applied rewrites77.3%
if 9.5999999999999993e-128 < t < 7.2e89Initial program 31.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.9%
if 7.2e89 < t < 1.08000000000000005e206Initial program 28.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites71.7%
if 1.08000000000000005e206 < t Initial program 20.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.7%
Taylor expanded in z around inf
Applied rewrites75.3%
Final simplification61.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma j t (* (- y) k)) b) y4)))
(if (<= b -7.6e+260)
t_1
(if (<= b -1.36e+194)
(*
(fma
(* y0 c)
y2
(fma (* (- a) y2) y1 (* (fma (- i) y1 (* y0 b)) (- j))))
x)
(if (<= b -1.25e+108)
(* (fma c i (* (- b) a)) (* t z))
(if (<= b -8.6e-240)
(*
(fma (fma y0 c (* (- a) y1)) y2 (fma (* (- y) i) c (* (* y1 j) i)))
x)
(if (<= b 1.65e-37)
(* (* (fma k y1 (* (- c) t)) y2) y4)
(if (<= b 5.5e+153)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(j, t, (-y * k)) * b) * y4;
double tmp;
if (b <= -7.6e+260) {
tmp = t_1;
} else if (b <= -1.36e+194) {
tmp = fma((y0 * c), y2, fma((-a * y2), y1, (fma(-i, y1, (y0 * b)) * -j))) * x;
} else if (b <= -1.25e+108) {
tmp = fma(c, i, (-b * a)) * (t * z);
} else if (b <= -8.6e-240) {
tmp = fma(fma(y0, c, (-a * y1)), y2, fma((-y * i), c, ((y1 * j) * i))) * x;
} else if (b <= 1.65e-37) {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
} else if (b <= 5.5e+153) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4) tmp = 0.0 if (b <= -7.6e+260) tmp = t_1; elseif (b <= -1.36e+194) tmp = Float64(fma(Float64(y0 * c), y2, fma(Float64(Float64(-a) * y2), y1, Float64(fma(Float64(-i), y1, Float64(y0 * b)) * Float64(-j)))) * x); elseif (b <= -1.25e+108) tmp = Float64(fma(c, i, Float64(Float64(-b) * a)) * Float64(t * z)); elseif (b <= -8.6e-240) tmp = Float64(fma(fma(y0, c, Float64(Float64(-a) * y1)), y2, fma(Float64(Float64(-y) * i), c, Float64(Float64(y1 * j) * i))) * x); elseif (b <= 1.65e-37) tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); elseif (b <= 5.5e+153) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision]}, If[LessEqual[b, -7.6e+260], t$95$1, If[LessEqual[b, -1.36e+194], N[(N[(N[(y0 * c), $MachinePrecision] * y2 + N[(N[((-a) * y2), $MachinePrecision] * y1 + N[(N[((-i) * y1 + N[(y0 * b), $MachinePrecision]), $MachinePrecision] * (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, -1.25e+108], N[(N[(c * i + N[((-b) * a), $MachinePrecision]), $MachinePrecision] * N[(t * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -8.6e-240], N[(N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[((-y) * i), $MachinePrecision] * c + N[(N[(y1 * j), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 1.65e-37], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[b, 5.5e+153], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{if}\;b \leq -7.6 \cdot 10^{+260}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.36 \cdot 10^{+194}:\\
\;\;\;\;\mathsf{fma}\left(y0 \cdot c, y2, \mathsf{fma}\left(\left(-a\right) \cdot y2, y1, \mathsf{fma}\left(-i, y1, y0 \cdot b\right) \cdot \left(-j\right)\right)\right) \cdot x\\
\mathbf{elif}\;b \leq -1.25 \cdot 10^{+108}:\\
\;\;\;\;\mathsf{fma}\left(c, i, \left(-b\right) \cdot a\right) \cdot \left(t \cdot z\right)\\
\mathbf{elif}\;b \leq -8.6 \cdot 10^{-240}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(\left(-y\right) \cdot i, c, \left(y1 \cdot j\right) \cdot i\right)\right) \cdot x\\
\mathbf{elif}\;b \leq 1.65 \cdot 10^{-37}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{+153}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -7.5999999999999995e260 or 5.5000000000000003e153 < b Initial program 26.9%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.3%
Taylor expanded in b around inf
Applied rewrites71.5%
if -7.5999999999999995e260 < b < -1.35999999999999994e194Initial program 50.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites75.0%
Taylor expanded in y around 0
Applied rewrites66.8%
Applied rewrites91.8%
if -1.35999999999999994e194 < b < -1.24999999999999998e108Initial program 27.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.9%
Taylor expanded in j around inf
Applied rewrites27.6%
Taylor expanded in z around inf
Applied rewrites73.8%
if -1.24999999999999998e108 < b < -8.60000000000000027e-240Initial program 33.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.7%
Taylor expanded in b around 0
Applied rewrites50.3%
Applied rewrites50.3%
if -8.60000000000000027e-240 < b < 1.64999999999999991e-37Initial program 31.5%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.7%
Taylor expanded in y1 around inf
Applied rewrites32.5%
Taylor expanded in k around 0
Applied rewrites17.2%
Taylor expanded in y2 around inf
Applied rewrites45.1%
if 1.64999999999999991e-37 < b < 5.5000000000000003e153Initial program 27.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.5%
Final simplification57.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* y0 c) (* y1 a)))
(t_2 (- (* y0 b) (* y1 i)))
(t_3 (* (fma (- (* i c) (* b a)) t (fma (- y3) t_1 (* t_2 k))) z)))
(if (<= z -2.2e+93)
t_3
(if (<= z -2.1e-16)
(* (* (- (* y2 c) (* j b)) y0) x)
(if (<= z -2.95e-252)
(*
(fma
(- (* j t) (* k y))
b
(fma (- (* y2 k) (* y3 j)) y1 (* (- (* y3 y) (* y2 t)) c)))
y4)
(if (<= z 1.95e-205)
(*
(fma
y
(- (* b a) (* i c))
(fma y2 t_1 (* (- (* y1 i) (* y0 b)) j)))
x)
(if (<= z 4.7e+55)
(*
(fma
(- (* y5 i) (* y4 b))
y
(fma (- (* y4 y1) (* y5 y0)) y2 (* t_2 z)))
k)
t_3)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (y0 * c) - (y1 * a);
double t_2 = (y0 * b) - (y1 * i);
double t_3 = fma(((i * c) - (b * a)), t, fma(-y3, t_1, (t_2 * k))) * z;
double tmp;
if (z <= -2.2e+93) {
tmp = t_3;
} else if (z <= -2.1e-16) {
tmp = (((y2 * c) - (j * b)) * y0) * x;
} else if (z <= -2.95e-252) {
tmp = fma(((j * t) - (k * y)), b, fma(((y2 * k) - (y3 * j)), y1, (((y3 * y) - (y2 * t)) * c))) * y4;
} else if (z <= 1.95e-205) {
tmp = fma(y, ((b * a) - (i * c)), fma(y2, t_1, (((y1 * i) - (y0 * b)) * j))) * x;
} else if (z <= 4.7e+55) {
tmp = fma(((y5 * i) - (y4 * b)), y, fma(((y4 * y1) - (y5 * y0)), y2, (t_2 * z))) * k;
} else {
tmp = t_3;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(y0 * c) - Float64(y1 * a)) t_2 = Float64(Float64(y0 * b) - Float64(y1 * i)) t_3 = Float64(fma(Float64(Float64(i * c) - Float64(b * a)), t, fma(Float64(-y3), t_1, Float64(t_2 * k))) * z) tmp = 0.0 if (z <= -2.2e+93) tmp = t_3; elseif (z <= -2.1e-16) tmp = Float64(Float64(Float64(Float64(y2 * c) - Float64(j * b)) * y0) * x); elseif (z <= -2.95e-252) tmp = Float64(fma(Float64(Float64(j * t) - Float64(k * y)), b, fma(Float64(Float64(y2 * k) - Float64(y3 * j)), y1, Float64(Float64(Float64(y3 * y) - Float64(y2 * t)) * c))) * y4); elseif (z <= 1.95e-205) tmp = Float64(fma(y, Float64(Float64(b * a) - Float64(i * c)), fma(y2, t_1, Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); elseif (z <= 4.7e+55) tmp = Float64(fma(Float64(Float64(y5 * i) - Float64(y4 * b)), y, fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), y2, Float64(t_2 * z))) * k); else tmp = t_3; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(i * c), $MachinePrecision] - N[(b * a), $MachinePrecision]), $MachinePrecision] * t + N[((-y3) * t$95$1 + N[(t$95$2 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -2.2e+93], t$95$3, If[LessEqual[z, -2.1e-16], N[(N[(N[(N[(y2 * c), $MachinePrecision] - N[(j * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, -2.95e-252], N[(N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * b + N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(N[(y3 * y), $MachinePrecision] - N[(y2 * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[z, 1.95e-205], N[(N[(y * N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision] + N[(y2 * t$95$1 + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 4.7e+55], N[(N[(N[(N[(y5 * i), $MachinePrecision] - N[(y4 * b), $MachinePrecision]), $MachinePrecision] * y + N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * y2 + N[(t$95$2 * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision], t$95$3]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y0 \cdot c - y1 \cdot a\\
t_2 := y0 \cdot b - y1 \cdot i\\
t_3 := \mathsf{fma}\left(i \cdot c - b \cdot a, t, \mathsf{fma}\left(-y3, t\_1, t\_2 \cdot k\right)\right) \cdot z\\
\mathbf{if}\;z \leq -2.2 \cdot 10^{+93}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{-16}:\\
\;\;\;\;\left(\left(y2 \cdot c - j \cdot b\right) \cdot y0\right) \cdot x\\
\mathbf{elif}\;z \leq -2.95 \cdot 10^{-252}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot t - k \cdot y, b, \mathsf{fma}\left(y2 \cdot k - y3 \cdot j, y1, \left(y3 \cdot y - y2 \cdot t\right) \cdot c\right)\right) \cdot y4\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{-205}:\\
\;\;\;\;\mathsf{fma}\left(y, b \cdot a - i \cdot c, \mathsf{fma}\left(y2, t\_1, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{elif}\;z \leq 4.7 \cdot 10^{+55}:\\
\;\;\;\;\mathsf{fma}\left(y5 \cdot i - y4 \cdot b, y, \mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, y2, t\_2 \cdot z\right)\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if z < -2.20000000000000021e93 or 4.7000000000000001e55 < z Initial program 30.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites65.4%
if -2.20000000000000021e93 < z < -2.1000000000000001e-16Initial program 10.5%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.6%
Taylor expanded in y0 around inf
Applied rewrites63.7%
if -2.1000000000000001e-16 < z < -2.9499999999999998e-252Initial program 35.6%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.0%
if -2.9499999999999998e-252 < z < 1.95000000000000009e-205Initial program 41.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.9%
if 1.95000000000000009e-205 < z < 4.7000000000000001e55Initial program 28.8%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.5%
Final simplification61.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* b a) (* i c)))
(t_2
(*
(fma
(- (* y3 z) (* y2 x))
y1
(fma (- (* y x) (* t z)) b (* (- (* y2 t) (* y3 y)) y5)))
a)))
(if (<= a -2.1e+63)
t_2
(if (<= a -2.1e-136)
(* (* (fma j y1 (* (- c) y)) i) x)
(if (<= a 2.3e-244)
(*
(fma
(- (* y5 i) (* y4 b))
k
(fma x t_1 (* (- (* y4 c) (* y5 a)) y3)))
y)
(if (<= a 1.7e+81)
(*
(fma
y
t_1
(fma y2 (- (* y0 c) (* y1 a)) (* (- (* y1 i) (* y0 b)) j)))
x)
(if (<= a 2.05e+166) (* (* (fma y2 y5 (* (- z) b)) a) t) t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (b * a) - (i * c);
double t_2 = fma(((y3 * z) - (y2 * x)), y1, fma(((y * x) - (t * z)), b, (((y2 * t) - (y3 * y)) * y5))) * a;
double tmp;
if (a <= -2.1e+63) {
tmp = t_2;
} else if (a <= -2.1e-136) {
tmp = (fma(j, y1, (-c * y)) * i) * x;
} else if (a <= 2.3e-244) {
tmp = fma(((y5 * i) - (y4 * b)), k, fma(x, t_1, (((y4 * c) - (y5 * a)) * y3))) * y;
} else if (a <= 1.7e+81) {
tmp = fma(y, t_1, fma(y2, ((y0 * c) - (y1 * a)), (((y1 * i) - (y0 * b)) * j))) * x;
} else if (a <= 2.05e+166) {
tmp = (fma(y2, y5, (-z * b)) * a) * t;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(b * a) - Float64(i * c)) t_2 = Float64(fma(Float64(Float64(y3 * z) - Float64(y2 * x)), y1, fma(Float64(Float64(y * x) - Float64(t * z)), b, Float64(Float64(Float64(y2 * t) - Float64(y3 * y)) * y5))) * a) tmp = 0.0 if (a <= -2.1e+63) tmp = t_2; elseif (a <= -2.1e-136) tmp = Float64(Float64(fma(j, y1, Float64(Float64(-c) * y)) * i) * x); elseif (a <= 2.3e-244) tmp = Float64(fma(Float64(Float64(y5 * i) - Float64(y4 * b)), k, fma(x, t_1, Float64(Float64(Float64(y4 * c) - Float64(y5 * a)) * y3))) * y); elseif (a <= 1.7e+81) tmp = Float64(fma(y, t_1, fma(y2, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y1 * i) - Float64(y0 * b)) * j))) * x); elseif (a <= 2.05e+166) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * a) * t); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(y3 * z), $MachinePrecision] - N[(y2 * x), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision] * b + N[(N[(N[(y2 * t), $MachinePrecision] - N[(y3 * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[a, -2.1e+63], t$95$2, If[LessEqual[a, -2.1e-136], N[(N[(N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[a, 2.3e-244], N[(N[(N[(N[(y5 * i), $MachinePrecision] - N[(y4 * b), $MachinePrecision]), $MachinePrecision] * k + N[(x * t$95$1 + N[(N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[a, 1.7e+81], N[(N[(y * t$95$1 + N[(y2 * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y1 * i), $MachinePrecision] - N[(y0 * b), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[a, 2.05e+166], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * t), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot a - i \cdot c\\
t_2 := \mathsf{fma}\left(y3 \cdot z - y2 \cdot x, y1, \mathsf{fma}\left(y \cdot x - t \cdot z, b, \left(y2 \cdot t - y3 \cdot y\right) \cdot y5\right)\right) \cdot a\\
\mathbf{if}\;a \leq -2.1 \cdot 10^{+63}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -2.1 \cdot 10^{-136}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right) \cdot i\right) \cdot x\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{-244}:\\
\;\;\;\;\mathsf{fma}\left(y5 \cdot i - y4 \cdot b, k, \mathsf{fma}\left(x, t\_1, \left(y4 \cdot c - y5 \cdot a\right) \cdot y3\right)\right) \cdot y\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{+81}:\\
\;\;\;\;\mathsf{fma}\left(y, t\_1, \mathsf{fma}\left(y2, y0 \cdot c - y1 \cdot a, \left(y1 \cdot i - y0 \cdot b\right) \cdot j\right)\right) \cdot x\\
\mathbf{elif}\;a \leq 2.05 \cdot 10^{+166}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot a\right) \cdot t\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -2.1000000000000002e63 or 2.0500000000000001e166 < a Initial program 23.5%
Taylor expanded in a around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.4%
if -2.1000000000000002e63 < a < -2.0999999999999999e-136Initial program 16.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.5%
Taylor expanded in b around 0
Applied rewrites37.1%
Taylor expanded in i around inf
Applied rewrites46.4%
if -2.0999999999999999e-136 < a < 2.3e-244Initial program 37.2%
Taylor expanded in y around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.5%
if 2.3e-244 < a < 1.70000000000000001e81Initial program 42.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.3%
if 1.70000000000000001e81 < a < 2.0500000000000001e166Initial program 30.0%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.4%
Taylor expanded in a around inf
Applied rewrites60.7%
Final simplification57.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* i c) (* b a))
t
(fma (- y3) (- (* y0 c) (* y1 a)) (* (- (* y0 b) (* y1 i)) k)))
z)))
(if (<= z -2.2e+93)
t_1
(if (<= z -2.1e-16)
(* (* (- (* y2 c) (* j b)) y0) x)
(if (<= z 5.4e-294)
(*
(fma
(- (* j t) (* k y))
b
(fma (- (* y2 k) (* y3 j)) y1 (* (- (* y3 y) (* y2 t)) c)))
y4)
(if (<= z 1.9e+61)
(*
(fma
(- i)
(* y1 z)
(fma
y
(fma (- b) y4 (* y5 i))
(fma (* y2 y1) y4 (* (fma b z (* (- y2) y5)) y0))))
k)
t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((i * c) - (b * a)), t, fma(-y3, ((y0 * c) - (y1 * a)), (((y0 * b) - (y1 * i)) * k))) * z;
double tmp;
if (z <= -2.2e+93) {
tmp = t_1;
} else if (z <= -2.1e-16) {
tmp = (((y2 * c) - (j * b)) * y0) * x;
} else if (z <= 5.4e-294) {
tmp = fma(((j * t) - (k * y)), b, fma(((y2 * k) - (y3 * j)), y1, (((y3 * y) - (y2 * t)) * c))) * y4;
} else if (z <= 1.9e+61) {
tmp = fma(-i, (y1 * z), fma(y, fma(-b, y4, (y5 * i)), fma((y2 * y1), y4, (fma(b, z, (-y2 * y5)) * y0)))) * k;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(i * c) - Float64(b * a)), t, fma(Float64(-y3), Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y0 * b) - Float64(y1 * i)) * k))) * z) tmp = 0.0 if (z <= -2.2e+93) tmp = t_1; elseif (z <= -2.1e-16) tmp = Float64(Float64(Float64(Float64(y2 * c) - Float64(j * b)) * y0) * x); elseif (z <= 5.4e-294) tmp = Float64(fma(Float64(Float64(j * t) - Float64(k * y)), b, fma(Float64(Float64(y2 * k) - Float64(y3 * j)), y1, Float64(Float64(Float64(y3 * y) - Float64(y2 * t)) * c))) * y4); elseif (z <= 1.9e+61) tmp = Float64(fma(Float64(-i), Float64(y1 * z), fma(y, fma(Float64(-b), y4, Float64(y5 * i)), fma(Float64(y2 * y1), y4, Float64(fma(b, z, Float64(Float64(-y2) * y5)) * y0)))) * k); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(i * c), $MachinePrecision] - N[(b * a), $MachinePrecision]), $MachinePrecision] * t + N[((-y3) * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * b), $MachinePrecision] - N[(y1 * i), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[z, -2.2e+93], t$95$1, If[LessEqual[z, -2.1e-16], N[(N[(N[(N[(y2 * c), $MachinePrecision] - N[(j * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[z, 5.4e-294], N[(N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * b + N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(N[(y3 * y), $MachinePrecision] - N[(y2 * t), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[z, 1.9e+61], N[(N[((-i) * N[(y1 * z), $MachinePrecision] + N[(y * N[((-b) * y4 + N[(y5 * i), $MachinePrecision]), $MachinePrecision] + N[(N[(y2 * y1), $MachinePrecision] * y4 + N[(N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * k), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(i \cdot c - b \cdot a, t, \mathsf{fma}\left(-y3, y0 \cdot c - y1 \cdot a, \left(y0 \cdot b - y1 \cdot i\right) \cdot k\right)\right) \cdot z\\
\mathbf{if}\;z \leq -2.2 \cdot 10^{+93}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.1 \cdot 10^{-16}:\\
\;\;\;\;\left(\left(y2 \cdot c - j \cdot b\right) \cdot y0\right) \cdot x\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{-294}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot t - k \cdot y, b, \mathsf{fma}\left(y2 \cdot k - y3 \cdot j, y1, \left(y3 \cdot y - y2 \cdot t\right) \cdot c\right)\right) \cdot y4\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{+61}:\\
\;\;\;\;\mathsf{fma}\left(-i, y1 \cdot z, \mathsf{fma}\left(y, \mathsf{fma}\left(-b, y4, y5 \cdot i\right), \mathsf{fma}\left(y2 \cdot y1, y4, \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right) \cdot y0\right)\right)\right) \cdot k\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.20000000000000021e93 or 1.89999999999999998e61 < z Initial program 30.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites66.1%
if -2.20000000000000021e93 < z < -2.1000000000000001e-16Initial program 10.5%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.6%
Taylor expanded in y0 around inf
Applied rewrites63.7%
if -2.1000000000000001e-16 < z < 5.40000000000000019e-294Initial program 38.2%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.4%
if 5.40000000000000019e-294 < z < 1.89999999999999998e61Initial program 30.8%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.7%
Taylor expanded in y0 around 0
Applied rewrites64.6%
Final simplification61.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* y x) (* t z))
a
(fma (- (* j t) (* k y)) y4 (* (- (* k z) (* j x)) y0)))
b))
(t_2 (- (* y0 c) (* y1 a))))
(if (<= b -6.8e+37)
t_1
(if (<= b 5.2e-229)
(*
(fma (- (* y4 y1) (* y5 y0)) k (fma x t_2 (* (- (* y5 a) (* y4 c)) t)))
y2)
(if (<= b 1.1e+72)
(*
(fma
(- (* y5 y0) (* y4 y1))
j
(fma (- z) t_2 (* (- (* y4 c) (* y5 a)) y)))
y3)
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((y * x) - (t * z)), a, fma(((j * t) - (k * y)), y4, (((k * z) - (j * x)) * y0))) * b;
double t_2 = (y0 * c) - (y1 * a);
double tmp;
if (b <= -6.8e+37) {
tmp = t_1;
} else if (b <= 5.2e-229) {
tmp = fma(((y4 * y1) - (y5 * y0)), k, fma(x, t_2, (((y5 * a) - (y4 * c)) * t))) * y2;
} else if (b <= 1.1e+72) {
tmp = fma(((y5 * y0) - (y4 * y1)), j, fma(-z, t_2, (((y4 * c) - (y5 * a)) * y))) * y3;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(y * x) - Float64(t * z)), a, fma(Float64(Float64(j * t) - Float64(k * y)), y4, Float64(Float64(Float64(k * z) - Float64(j * x)) * y0))) * b) t_2 = Float64(Float64(y0 * c) - Float64(y1 * a)) tmp = 0.0 if (b <= -6.8e+37) tmp = t_1; elseif (b <= 5.2e-229) tmp = Float64(fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), k, fma(x, t_2, Float64(Float64(Float64(y5 * a) - Float64(y4 * c)) * t))) * y2); elseif (b <= 1.1e+72) tmp = Float64(fma(Float64(Float64(y5 * y0) - Float64(y4 * y1)), j, fma(Float64(-z), t_2, Float64(Float64(Float64(y4 * c) - Float64(y5 * a)) * y))) * y3); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * y4 + N[(N[(N[(k * z), $MachinePrecision] - N[(j * x), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.8e+37], t$95$1, If[LessEqual[b, 5.2e-229], N[(N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * k + N[(x * t$95$2 + N[(N[(N[(y5 * a), $MachinePrecision] - N[(y4 * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], If[LessEqual[b, 1.1e+72], N[(N[(N[(N[(y5 * y0), $MachinePrecision] - N[(y4 * y1), $MachinePrecision]), $MachinePrecision] * j + N[((-z) * t$95$2 + N[(N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y \cdot x - t \cdot z, a, \mathsf{fma}\left(j \cdot t - k \cdot y, y4, \left(k \cdot z - j \cdot x\right) \cdot y0\right)\right) \cdot b\\
t_2 := y0 \cdot c - y1 \cdot a\\
\mathbf{if}\;b \leq -6.8 \cdot 10^{+37}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 5.2 \cdot 10^{-229}:\\
\;\;\;\;\mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, k, \mathsf{fma}\left(x, t\_2, \left(y5 \cdot a - y4 \cdot c\right) \cdot t\right)\right) \cdot y2\\
\mathbf{elif}\;b \leq 1.1 \cdot 10^{+72}:\\
\;\;\;\;\mathsf{fma}\left(y5 \cdot y0 - y4 \cdot y1, j, \mathsf{fma}\left(-z, t\_2, \left(y4 \cdot c - y5 \cdot a\right) \cdot y\right)\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -6.80000000000000011e37 or 1.1e72 < b Initial program 28.2%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites65.1%
if -6.80000000000000011e37 < b < 5.2000000000000003e-229Initial program 34.6%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.6%
if 5.2000000000000003e-229 < b < 1.1e72Initial program 32.8%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Final simplification58.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (- a) y1)))
(if (<= y2 -2.35e+260)
(* (* (* y2 y1) k) y4)
(if (<= y2 -8.6e-42)
(* (fma (fma y0 c t_1) y2 (fma (* (- y) i) c (* (* y1 j) i))) x)
(if (<= y2 -1.85e-192)
(* (* (fma j t (* (- y) k)) b) y4)
(if (<= y2 1.05e-237)
(* (* (fma j x (* (- z) k)) (- y0)) b)
(if (<= y2 2e-29)
(* (* (- (* y0 k) (* a t)) z) b)
(if (<= y2 1.16e+122)
(* (fma y2 (fma c y0 t_1) (* (fma (- i) y1 (* y0 b)) (- j))) x)
(* (* (fma k y1 (* (- c) t)) y2) y4)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = -a * y1;
double tmp;
if (y2 <= -2.35e+260) {
tmp = ((y2 * y1) * k) * y4;
} else if (y2 <= -8.6e-42) {
tmp = fma(fma(y0, c, t_1), y2, fma((-y * i), c, ((y1 * j) * i))) * x;
} else if (y2 <= -1.85e-192) {
tmp = (fma(j, t, (-y * k)) * b) * y4;
} else if (y2 <= 1.05e-237) {
tmp = (fma(j, x, (-z * k)) * -y0) * b;
} else if (y2 <= 2e-29) {
tmp = (((y0 * k) - (a * t)) * z) * b;
} else if (y2 <= 1.16e+122) {
tmp = fma(y2, fma(c, y0, t_1), (fma(-i, y1, (y0 * b)) * -j)) * x;
} else {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(-a) * y1) tmp = 0.0 if (y2 <= -2.35e+260) tmp = Float64(Float64(Float64(y2 * y1) * k) * y4); elseif (y2 <= -8.6e-42) tmp = Float64(fma(fma(y0, c, t_1), y2, fma(Float64(Float64(-y) * i), c, Float64(Float64(y1 * j) * i))) * x); elseif (y2 <= -1.85e-192) tmp = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4); elseif (y2 <= 1.05e-237) tmp = Float64(Float64(fma(j, x, Float64(Float64(-z) * k)) * Float64(-y0)) * b); elseif (y2 <= 2e-29) tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); elseif (y2 <= 1.16e+122) tmp = Float64(fma(y2, fma(c, y0, t_1), Float64(fma(Float64(-i), y1, Float64(y0 * b)) * Float64(-j))) * x); else tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[((-a) * y1), $MachinePrecision]}, If[LessEqual[y2, -2.35e+260], N[(N[(N[(y2 * y1), $MachinePrecision] * k), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, -8.6e-42], N[(N[(N[(y0 * c + t$95$1), $MachinePrecision] * y2 + N[(N[((-y) * i), $MachinePrecision] * c + N[(N[(y1 * j), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y2, -1.85e-192], N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, 1.05e-237], N[(N[(N[(j * x + N[((-z) * k), $MachinePrecision]), $MachinePrecision] * (-y0)), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 2e-29], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 1.16e+122], N[(N[(y2 * N[(c * y0 + t$95$1), $MachinePrecision] + N[(N[((-i) * y1 + N[(y0 * b), $MachinePrecision]), $MachinePrecision] * (-j)), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot y1\\
\mathbf{if}\;y2 \leq -2.35 \cdot 10^{+260}:\\
\;\;\;\;\left(\left(y2 \cdot y1\right) \cdot k\right) \cdot y4\\
\mathbf{elif}\;y2 \leq -8.6 \cdot 10^{-42}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y0, c, t\_1\right), y2, \mathsf{fma}\left(\left(-y\right) \cdot i, c, \left(y1 \cdot j\right) \cdot i\right)\right) \cdot x\\
\mathbf{elif}\;y2 \leq -1.85 \cdot 10^{-192}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{elif}\;y2 \leq 1.05 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, x, \left(-z\right) \cdot k\right) \cdot \left(-y0\right)\right) \cdot b\\
\mathbf{elif}\;y2 \leq 2 \cdot 10^{-29}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;y2 \leq 1.16 \cdot 10^{+122}:\\
\;\;\;\;\mathsf{fma}\left(y2, \mathsf{fma}\left(c, y0, t\_1\right), \mathsf{fma}\left(-i, y1, y0 \cdot b\right) \cdot \left(-j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\end{array}
\end{array}
if y2 < -2.35000000000000011e260Initial program 0.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.9%
Taylor expanded in y1 around inf
Applied rewrites85.7%
Taylor expanded in k around inf
Applied rewrites100.0%
if -2.35000000000000011e260 < y2 < -8.6000000000000002e-42Initial program 32.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.2%
Taylor expanded in b around 0
Applied rewrites50.6%
Applied rewrites50.6%
if -8.6000000000000002e-42 < y2 < -1.85e-192Initial program 43.4%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites65.5%
if -1.85e-192 < y2 < 1.0500000000000001e-237Initial program 37.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.0%
Taylor expanded in y0 around inf
Applied rewrites58.2%
if 1.0500000000000001e-237 < y2 < 1.99999999999999989e-29Initial program 33.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.7%
Taylor expanded in z around inf
Applied rewrites43.7%
if 1.99999999999999989e-29 < y2 < 1.16e122Initial program 34.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites62.3%
Taylor expanded in y around 0
Applied rewrites54.4%
Taylor expanded in y around 0
Applied rewrites58.3%
if 1.16e122 < y2 Initial program 18.1%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.1%
Taylor expanded in y1 around inf
Applied rewrites56.1%
Taylor expanded in k around 0
Applied rewrites21.5%
Taylor expanded in y2 around inf
Applied rewrites60.5%
Final simplification55.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y2 -1.02e-41)
(* (fma (* j i) y1 (* (fma (- a) y1 (* y0 c)) y2)) x)
(if (<= y2 -1.85e-192)
(* (* (fma j t (* (- y) k)) b) y4)
(if (<= y2 1.05e-237)
(* (* (fma j x (* (- z) k)) (- y0)) b)
(if (<= y2 2e-29)
(* (* (- (* y0 k) (* a t)) z) b)
(if (<= y2 1.16e+122)
(*
(fma y2 (fma c y0 (* (- a) y1)) (* (fma (- i) y1 (* y0 b)) (- j)))
x)
(* (* (fma k y1 (* (- c) t)) y2) y4)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y2 <= -1.02e-41) {
tmp = fma((j * i), y1, (fma(-a, y1, (y0 * c)) * y2)) * x;
} else if (y2 <= -1.85e-192) {
tmp = (fma(j, t, (-y * k)) * b) * y4;
} else if (y2 <= 1.05e-237) {
tmp = (fma(j, x, (-z * k)) * -y0) * b;
} else if (y2 <= 2e-29) {
tmp = (((y0 * k) - (a * t)) * z) * b;
} else if (y2 <= 1.16e+122) {
tmp = fma(y2, fma(c, y0, (-a * y1)), (fma(-i, y1, (y0 * b)) * -j)) * x;
} else {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y2 <= -1.02e-41) tmp = Float64(fma(Float64(j * i), y1, Float64(fma(Float64(-a), y1, Float64(y0 * c)) * y2)) * x); elseif (y2 <= -1.85e-192) tmp = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4); elseif (y2 <= 1.05e-237) tmp = Float64(Float64(fma(j, x, Float64(Float64(-z) * k)) * Float64(-y0)) * b); elseif (y2 <= 2e-29) tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); elseif (y2 <= 1.16e+122) tmp = Float64(fma(y2, fma(c, y0, Float64(Float64(-a) * y1)), Float64(fma(Float64(-i), y1, Float64(y0 * b)) * Float64(-j))) * x); else tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y2, -1.02e-41], N[(N[(N[(j * i), $MachinePrecision] * y1 + N[(N[((-a) * y1 + N[(y0 * c), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y2, -1.85e-192], N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, 1.05e-237], N[(N[(N[(j * x + N[((-z) * k), $MachinePrecision]), $MachinePrecision] * (-y0)), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 2e-29], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 1.16e+122], N[(N[(y2 * N[(c * y0 + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] + N[(N[((-i) * y1 + N[(y0 * b), $MachinePrecision]), $MachinePrecision] * (-j)), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y2 \leq -1.02 \cdot 10^{-41}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot i, y1, \mathsf{fma}\left(-a, y1, y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{elif}\;y2 \leq -1.85 \cdot 10^{-192}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{elif}\;y2 \leq 1.05 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, x, \left(-z\right) \cdot k\right) \cdot \left(-y0\right)\right) \cdot b\\
\mathbf{elif}\;y2 \leq 2 \cdot 10^{-29}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\mathbf{elif}\;y2 \leq 1.16 \cdot 10^{+122}:\\
\;\;\;\;\mathsf{fma}\left(y2, \mathsf{fma}\left(c, y0, \left(-a\right) \cdot y1\right), \mathsf{fma}\left(-i, y1, y0 \cdot b\right) \cdot \left(-j\right)\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\end{array}
\end{array}
if y2 < -1.02e-41Initial program 29.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.2%
Taylor expanded in b around 0
Applied rewrites48.5%
Taylor expanded in y around 0
Applied rewrites47.5%
if -1.02e-41 < y2 < -1.85e-192Initial program 43.4%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites65.5%
if -1.85e-192 < y2 < 1.0500000000000001e-237Initial program 37.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.0%
Taylor expanded in y0 around inf
Applied rewrites58.2%
if 1.0500000000000001e-237 < y2 < 1.99999999999999989e-29Initial program 33.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.7%
Taylor expanded in z around inf
Applied rewrites43.7%
if 1.99999999999999989e-29 < y2 < 1.16e122Initial program 34.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites62.3%
Taylor expanded in y around 0
Applied rewrites54.4%
Taylor expanded in y around 0
Applied rewrites58.3%
if 1.16e122 < y2 Initial program 18.1%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.1%
Taylor expanded in y1 around inf
Applied rewrites56.1%
Taylor expanded in k around 0
Applied rewrites21.5%
Taylor expanded in y2 around inf
Applied rewrites60.5%
Final simplification53.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(fma
(- (* y x) (* t z))
a
(fma (- (* j t) (* k y)) y4 (* (- (* k z) (* j x)) y0)))
b)))
(if (<= b -6.8e+37)
t_1
(if (<= b 4.1e+37)
(*
(fma
(- (* y4 y1) (* y5 y0))
k
(fma x (- (* y0 c) (* y1 a)) (* (- (* y5 a) (* y4 c)) t)))
y2)
t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = fma(((y * x) - (t * z)), a, fma(((j * t) - (k * y)), y4, (((k * z) - (j * x)) * y0))) * b;
double tmp;
if (b <= -6.8e+37) {
tmp = t_1;
} else if (b <= 4.1e+37) {
tmp = fma(((y4 * y1) - (y5 * y0)), k, fma(x, ((y0 * c) - (y1 * a)), (((y5 * a) - (y4 * c)) * t))) * y2;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(fma(Float64(Float64(y * x) - Float64(t * z)), a, fma(Float64(Float64(j * t) - Float64(k * y)), y4, Float64(Float64(Float64(k * z) - Float64(j * x)) * y0))) * b) tmp = 0.0 if (b <= -6.8e+37) tmp = t_1; elseif (b <= 4.1e+37) tmp = Float64(fma(Float64(Float64(y4 * y1) - Float64(y5 * y0)), k, fma(x, Float64(Float64(y0 * c) - Float64(y1 * a)), Float64(Float64(Float64(y5 * a) - Float64(y4 * c)) * t))) * y2); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * y4 + N[(N[(N[(k * z), $MachinePrecision] - N[(j * x), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]}, If[LessEqual[b, -6.8e+37], t$95$1, If[LessEqual[b, 4.1e+37], N[(N[(N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * k + N[(x * N[(N[(y0 * c), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y5 * a), $MachinePrecision] - N[(y4 * c), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y \cdot x - t \cdot z, a, \mathsf{fma}\left(j \cdot t - k \cdot y, y4, \left(k \cdot z - j \cdot x\right) \cdot y0\right)\right) \cdot b\\
\mathbf{if}\;b \leq -6.8 \cdot 10^{+37}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 4.1 \cdot 10^{+37}:\\
\;\;\;\;\mathsf{fma}\left(y4 \cdot y1 - y5 \cdot y0, k, \mathsf{fma}\left(x, y0 \cdot c - y1 \cdot a, \left(y5 \cdot a - y4 \cdot c\right) \cdot t\right)\right) \cdot y2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -6.80000000000000011e37 or 4.0999999999999998e37 < b Initial program 28.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.5%
if -6.80000000000000011e37 < b < 4.0999999999999998e37Initial program 33.7%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.8%
Final simplification55.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma j t (* (- y) k)) b) y4)))
(if (<= b -1.5e+243)
t_1
(if (<= b -3.6e+130)
(* (* (fma y2 y5 (* (- z) b)) a) t)
(if (<= b -6.2e-159)
(* (* (fma c y0 (* (- a) y1)) y2) x)
(if (<= b -3.8e-237)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(if (<= b 1.35e+45)
(* (* (fma k y1 (* (- c) t)) y2) y4)
(if (<= b 3e+158)
(* (* (fma j x (* (- z) k)) (- y0)) b)
t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(j, t, (-y * k)) * b) * y4;
double tmp;
if (b <= -1.5e+243) {
tmp = t_1;
} else if (b <= -3.6e+130) {
tmp = (fma(y2, y5, (-z * b)) * a) * t;
} else if (b <= -6.2e-159) {
tmp = (fma(c, y0, (-a * y1)) * y2) * x;
} else if (b <= -3.8e-237) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else if (b <= 1.35e+45) {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
} else if (b <= 3e+158) {
tmp = (fma(j, x, (-z * k)) * -y0) * b;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4) tmp = 0.0 if (b <= -1.5e+243) tmp = t_1; elseif (b <= -3.6e+130) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * a) * t); elseif (b <= -6.2e-159) tmp = Float64(Float64(fma(c, y0, Float64(Float64(-a) * y1)) * y2) * x); elseif (b <= -3.8e-237) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); elseif (b <= 1.35e+45) tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); elseif (b <= 3e+158) tmp = Float64(Float64(fma(j, x, Float64(Float64(-z) * k)) * Float64(-y0)) * b); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision]}, If[LessEqual[b, -1.5e+243], t$95$1, If[LessEqual[b, -3.6e+130], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, -6.2e-159], N[(N[(N[(c * y0 + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, -3.8e-237], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[b, 1.35e+45], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[b, 3e+158], N[(N[(N[(j * x + N[((-z) * k), $MachinePrecision]), $MachinePrecision] * (-y0)), $MachinePrecision] * b), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{if}\;b \leq -1.5 \cdot 10^{+243}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3.6 \cdot 10^{+130}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot a\right) \cdot t\\
\mathbf{elif}\;b \leq -6.2 \cdot 10^{-159}:\\
\;\;\;\;\left(\mathsf{fma}\left(c, y0, \left(-a\right) \cdot y1\right) \cdot y2\right) \cdot x\\
\mathbf{elif}\;b \leq -3.8 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{elif}\;b \leq 1.35 \cdot 10^{+45}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\mathbf{elif}\;b \leq 3 \cdot 10^{+158}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, x, \left(-z\right) \cdot k\right) \cdot \left(-y0\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.49999999999999992e243 or 3e158 < b Initial program 29.1%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.2%
Taylor expanded in b around inf
Applied rewrites71.3%
if -1.49999999999999992e243 < b < -3.6000000000000001e130Initial program 38.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in a around inf
Applied rewrites71.6%
if -3.6000000000000001e130 < b < -6.2e-159Initial program 35.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.8%
Taylor expanded in y2 around inf
Applied rewrites46.3%
if -6.2e-159 < b < -3.80000000000000024e-237Initial program 25.0%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.8%
Taylor expanded in z around inf
Applied rewrites38.1%
Taylor expanded in y0 around inf
Applied rewrites63.4%
if -3.80000000000000024e-237 < b < 1.34999999999999992e45Initial program 35.3%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.7%
Taylor expanded in y1 around inf
Applied rewrites31.9%
Taylor expanded in k around 0
Applied rewrites16.9%
Taylor expanded in y2 around inf
Applied rewrites41.1%
if 1.34999999999999992e45 < b < 3e158Initial program 9.1%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.6%
Taylor expanded in y0 around inf
Applied rewrites55.1%
Final simplification53.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y2 -4.5e+260)
(* (* (* y2 y1) k) y4)
(if (<= y2 -7.2e+102)
(* (* y0 k) (fma b z (* (- y2) y5)))
(if (<= y2 -1.2e-11)
(* (* (- (* y1 z) (* y5 y)) y3) a)
(if (<= y2 -1.85e-192)
(* (* (fma j t (* (- y) k)) b) y4)
(if (<= y2 1.05e-237)
(* (* (fma j x (* (- z) k)) (- y0)) b)
(if (<= y2 6.2e+80)
(* (* (- (* y0 k) (* a t)) z) b)
(* (* (- (* y2 c) (* j b)) y0) x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y2 <= -4.5e+260) {
tmp = ((y2 * y1) * k) * y4;
} else if (y2 <= -7.2e+102) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else if (y2 <= -1.2e-11) {
tmp = (((y1 * z) - (y5 * y)) * y3) * a;
} else if (y2 <= -1.85e-192) {
tmp = (fma(j, t, (-y * k)) * b) * y4;
} else if (y2 <= 1.05e-237) {
tmp = (fma(j, x, (-z * k)) * -y0) * b;
} else if (y2 <= 6.2e+80) {
tmp = (((y0 * k) - (a * t)) * z) * b;
} else {
tmp = (((y2 * c) - (j * b)) * y0) * x;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y2 <= -4.5e+260) tmp = Float64(Float64(Float64(y2 * y1) * k) * y4); elseif (y2 <= -7.2e+102) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); elseif (y2 <= -1.2e-11) tmp = Float64(Float64(Float64(Float64(y1 * z) - Float64(y5 * y)) * y3) * a); elseif (y2 <= -1.85e-192) tmp = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4); elseif (y2 <= 1.05e-237) tmp = Float64(Float64(fma(j, x, Float64(Float64(-z) * k)) * Float64(-y0)) * b); elseif (y2 <= 6.2e+80) tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); else tmp = Float64(Float64(Float64(Float64(y2 * c) - Float64(j * b)) * y0) * x); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y2, -4.5e+260], N[(N[(N[(y2 * y1), $MachinePrecision] * k), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, -7.2e+102], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y2, -1.2e-11], N[(N[(N[(N[(y1 * z), $MachinePrecision] - N[(y5 * y), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[y2, -1.85e-192], N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, 1.05e-237], N[(N[(N[(j * x + N[((-z) * k), $MachinePrecision]), $MachinePrecision] * (-y0)), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 6.2e+80], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision], N[(N[(N[(N[(y2 * c), $MachinePrecision] - N[(j * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * x), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y2 \leq -4.5 \cdot 10^{+260}:\\
\;\;\;\;\left(\left(y2 \cdot y1\right) \cdot k\right) \cdot y4\\
\mathbf{elif}\;y2 \leq -7.2 \cdot 10^{+102}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{elif}\;y2 \leq -1.2 \cdot 10^{-11}:\\
\;\;\;\;\left(\left(y1 \cdot z - y5 \cdot y\right) \cdot y3\right) \cdot a\\
\mathbf{elif}\;y2 \leq -1.85 \cdot 10^{-192}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{elif}\;y2 \leq 1.05 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, x, \left(-z\right) \cdot k\right) \cdot \left(-y0\right)\right) \cdot b\\
\mathbf{elif}\;y2 \leq 6.2 \cdot 10^{+80}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y2 \cdot c - j \cdot b\right) \cdot y0\right) \cdot x\\
\end{array}
\end{array}
if y2 < -4.50000000000000023e260Initial program 0.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites33.3%
Taylor expanded in y1 around inf
Applied rewrites83.3%
Taylor expanded in k around inf
Applied rewrites100.0%
if -4.50000000000000023e260 < y2 < -7.2000000000000003e102Initial program 20.8%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites36.8%
Taylor expanded in y0 around inf
Applied rewrites54.3%
if -7.2000000000000003e102 < y2 < -1.2000000000000001e-11Initial program 37.0%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.7%
Taylor expanded in a around inf
Applied rewrites48.7%
if -1.2000000000000001e-11 < y2 < -1.85e-192Initial program 48.3%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.7%
Taylor expanded in b around inf
Applied rewrites61.5%
if -1.85e-192 < y2 < 1.0500000000000001e-237Initial program 37.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.0%
Taylor expanded in y0 around inf
Applied rewrites58.2%
if 1.0500000000000001e-237 < y2 < 6.19999999999999976e80Initial program 31.1%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites34.8%
Taylor expanded in z around inf
Applied rewrites38.9%
if 6.19999999999999976e80 < y2 Initial program 24.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.8%
Taylor expanded in y0 around inf
Applied rewrites60.3%
Final simplification53.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma j t (* (- y) k)) b) y4)))
(if (<= b -1.5e+243)
t_1
(if (<= b -3.6e+130)
(* (* (fma y2 y5 (* (- z) b)) a) t)
(if (<= b -6.2e-159)
(* (* (fma c y0 (* (- a) y1)) y2) x)
(if (<= b -3.8e-237)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(if (<= b 1.25e+45)
(* (* (fma k y1 (* (- c) t)) y2) y4)
(if (<= b 1.7e+159)
(* (* y0 k) (fma b z (* (- y2) y5)))
t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(j, t, (-y * k)) * b) * y4;
double tmp;
if (b <= -1.5e+243) {
tmp = t_1;
} else if (b <= -3.6e+130) {
tmp = (fma(y2, y5, (-z * b)) * a) * t;
} else if (b <= -6.2e-159) {
tmp = (fma(c, y0, (-a * y1)) * y2) * x;
} else if (b <= -3.8e-237) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else if (b <= 1.25e+45) {
tmp = (fma(k, y1, (-c * t)) * y2) * y4;
} else if (b <= 1.7e+159) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4) tmp = 0.0 if (b <= -1.5e+243) tmp = t_1; elseif (b <= -3.6e+130) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * a) * t); elseif (b <= -6.2e-159) tmp = Float64(Float64(fma(c, y0, Float64(Float64(-a) * y1)) * y2) * x); elseif (b <= -3.8e-237) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); elseif (b <= 1.25e+45) tmp = Float64(Float64(fma(k, y1, Float64(Float64(-c) * t)) * y2) * y4); elseif (b <= 1.7e+159) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision]}, If[LessEqual[b, -1.5e+243], t$95$1, If[LessEqual[b, -3.6e+130], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, -6.2e-159], N[(N[(N[(c * y0 + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, -3.8e-237], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[b, 1.25e+45], N[(N[(N[(k * y1 + N[((-c) * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[b, 1.7e+159], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{if}\;b \leq -1.5 \cdot 10^{+243}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3.6 \cdot 10^{+130}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot a\right) \cdot t\\
\mathbf{elif}\;b \leq -6.2 \cdot 10^{-159}:\\
\;\;\;\;\left(\mathsf{fma}\left(c, y0, \left(-a\right) \cdot y1\right) \cdot y2\right) \cdot x\\
\mathbf{elif}\;b \leq -3.8 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{elif}\;b \leq 1.25 \cdot 10^{+45}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y1, \left(-c\right) \cdot t\right) \cdot y2\right) \cdot y4\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{+159}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.49999999999999992e243 or 1.69999999999999996e159 < b Initial program 29.1%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.2%
Taylor expanded in b around inf
Applied rewrites71.3%
if -1.49999999999999992e243 < b < -3.6000000000000001e130Initial program 38.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in a around inf
Applied rewrites71.6%
if -3.6000000000000001e130 < b < -6.2e-159Initial program 35.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.8%
Taylor expanded in y2 around inf
Applied rewrites46.3%
if -6.2e-159 < b < -3.80000000000000024e-237Initial program 25.0%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.8%
Taylor expanded in z around inf
Applied rewrites38.1%
Taylor expanded in y0 around inf
Applied rewrites63.4%
if -3.80000000000000024e-237 < b < 1.25e45Initial program 35.3%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.7%
Taylor expanded in y1 around inf
Applied rewrites31.9%
Taylor expanded in k around 0
Applied rewrites16.9%
Taylor expanded in y2 around inf
Applied rewrites41.1%
if 1.25e45 < b < 1.69999999999999996e159Initial program 9.1%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites36.8%
Taylor expanded in y0 around inf
Applied rewrites50.7%
Final simplification53.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma j t (* (- y) k)) b) y4)))
(if (<= b -1.5e+243)
t_1
(if (<= b -3.6e+130)
(* (* (fma y2 y5 (* (- z) b)) a) t)
(if (<= b -6.2e-159)
(* (* (fma c y0 (* (- a) y1)) y2) x)
(if (<= b 2.1e-273)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(if (<= b 3.4e-61)
(* (* (fma i z (* (- y4) y2)) c) t)
(if (<= b 5.8e+136)
(* (* (fma c y4 (* (- a) y5)) y3) y)
t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(j, t, (-y * k)) * b) * y4;
double tmp;
if (b <= -1.5e+243) {
tmp = t_1;
} else if (b <= -3.6e+130) {
tmp = (fma(y2, y5, (-z * b)) * a) * t;
} else if (b <= -6.2e-159) {
tmp = (fma(c, y0, (-a * y1)) * y2) * x;
} else if (b <= 2.1e-273) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else if (b <= 3.4e-61) {
tmp = (fma(i, z, (-y4 * y2)) * c) * t;
} else if (b <= 5.8e+136) {
tmp = (fma(c, y4, (-a * y5)) * y3) * y;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4) tmp = 0.0 if (b <= -1.5e+243) tmp = t_1; elseif (b <= -3.6e+130) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * a) * t); elseif (b <= -6.2e-159) tmp = Float64(Float64(fma(c, y0, Float64(Float64(-a) * y1)) * y2) * x); elseif (b <= 2.1e-273) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); elseif (b <= 3.4e-61) tmp = Float64(Float64(fma(i, z, Float64(Float64(-y4) * y2)) * c) * t); elseif (b <= 5.8e+136) tmp = Float64(Float64(fma(c, y4, Float64(Float64(-a) * y5)) * y3) * y); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision]}, If[LessEqual[b, -1.5e+243], t$95$1, If[LessEqual[b, -3.6e+130], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, -6.2e-159], N[(N[(N[(c * y0 + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[b, 2.1e-273], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[b, 3.4e-61], N[(N[(N[(i * z + N[((-y4) * y2), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[b, 5.8e+136], N[(N[(N[(c * y4 + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision] * y), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{if}\;b \leq -1.5 \cdot 10^{+243}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3.6 \cdot 10^{+130}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot a\right) \cdot t\\
\mathbf{elif}\;b \leq -6.2 \cdot 10^{-159}:\\
\;\;\;\;\left(\mathsf{fma}\left(c, y0, \left(-a\right) \cdot y1\right) \cdot y2\right) \cdot x\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{-273}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{elif}\;b \leq 3.4 \cdot 10^{-61}:\\
\;\;\;\;\left(\mathsf{fma}\left(i, z, \left(-y4\right) \cdot y2\right) \cdot c\right) \cdot t\\
\mathbf{elif}\;b \leq 5.8 \cdot 10^{+136}:\\
\;\;\;\;\left(\mathsf{fma}\left(c, y4, \left(-a\right) \cdot y5\right) \cdot y3\right) \cdot y\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.49999999999999992e243 or 5.79999999999999949e136 < b Initial program 27.8%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.3%
Taylor expanded in b around inf
Applied rewrites69.2%
if -1.49999999999999992e243 < b < -3.6000000000000001e130Initial program 38.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.8%
Taylor expanded in a around inf
Applied rewrites71.6%
if -3.6000000000000001e130 < b < -6.2e-159Initial program 35.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.8%
Taylor expanded in y2 around inf
Applied rewrites46.3%
if -6.2e-159 < b < 2.1000000000000002e-273Initial program 32.3%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in z around inf
Applied rewrites35.9%
Taylor expanded in y0 around inf
Applied rewrites43.5%
if 2.1000000000000002e-273 < b < 3.3999999999999998e-61Initial program 33.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in c around inf
Applied rewrites45.1%
if 3.3999999999999998e-61 < b < 5.79999999999999949e136Initial program 23.7%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in y around inf
Applied rewrites37.8%
Final simplification52.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= t -1.08e+158)
(* (* (fma y2 y5 (* (- z) b)) t) a)
(if (<= t -9.6e-44)
(* (* y0 k) (fma b z (* (- y2) y5)))
(if (<= t -5.5e-141)
(* (* (fma j y0 (* (- a) y)) y5) y3)
(if (<= t -1.35e-217)
(* (* (fma j y1 (* (- c) y)) i) x)
(if (<= t 3.4e-38)
(* (fma a y (* (- j) y0)) (* b x))
(if (<= t 1.05e+44)
(* (* (fma j y5 (* (- z) c)) y0) y3)
(* (* (fma j y4 (* (- z) a)) t) b))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -1.08e+158) {
tmp = (fma(y2, y5, (-z * b)) * t) * a;
} else if (t <= -9.6e-44) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else if (t <= -5.5e-141) {
tmp = (fma(j, y0, (-a * y)) * y5) * y3;
} else if (t <= -1.35e-217) {
tmp = (fma(j, y1, (-c * y)) * i) * x;
} else if (t <= 3.4e-38) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else if (t <= 1.05e+44) {
tmp = (fma(j, y5, (-z * c)) * y0) * y3;
} else {
tmp = (fma(j, y4, (-z * a)) * t) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -1.08e+158) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a); elseif (t <= -9.6e-44) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); elseif (t <= -5.5e-141) tmp = Float64(Float64(fma(j, y0, Float64(Float64(-a) * y)) * y5) * y3); elseif (t <= -1.35e-217) tmp = Float64(Float64(fma(j, y1, Float64(Float64(-c) * y)) * i) * x); elseif (t <= 3.4e-38) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); elseif (t <= 1.05e+44) tmp = Float64(Float64(fma(j, y5, Float64(Float64(-z) * c)) * y0) * y3); else tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -1.08e+158], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, -9.6e-44], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5.5e-141], N[(N[(N[(j * y0 + N[((-a) * y), $MachinePrecision]), $MachinePrecision] * y5), $MachinePrecision] * y3), $MachinePrecision], If[LessEqual[t, -1.35e-217], N[(N[(N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[t, 3.4e-38], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.05e+44], N[(N[(N[(j * y5 + N[((-z) * c), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * y3), $MachinePrecision], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.08 \cdot 10^{+158}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;t \leq -9.6 \cdot 10^{-44}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{elif}\;t \leq -5.5 \cdot 10^{-141}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y0, \left(-a\right) \cdot y\right) \cdot y5\right) \cdot y3\\
\mathbf{elif}\;t \leq -1.35 \cdot 10^{-217}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right) \cdot i\right) \cdot x\\
\mathbf{elif}\;t \leq 3.4 \cdot 10^{-38}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{elif}\;t \leq 1.05 \cdot 10^{+44}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y5, \left(-z\right) \cdot c\right) \cdot y0\right) \cdot y3\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\end{array}
\end{array}
if t < -1.08e158Initial program 29.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.0%
Taylor expanded in a around inf
Applied rewrites57.3%
if -1.08e158 < t < -9.60000000000000035e-44Initial program 37.9%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.7%
Taylor expanded in y0 around inf
Applied rewrites44.3%
if -9.60000000000000035e-44 < t < -5.4999999999999998e-141Initial program 35.4%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites60.1%
Taylor expanded in z around inf
Applied rewrites31.6%
Taylor expanded in y5 around inf
Applied rewrites64.4%
if -5.4999999999999998e-141 < t < -1.35000000000000008e-217Initial program 31.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.6%
Taylor expanded in b around 0
Applied rewrites47.5%
Taylor expanded in i around inf
Applied rewrites48.8%
if -1.35000000000000008e-217 < t < 3.4000000000000002e-38Initial program 34.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.9%
Taylor expanded in b around 0
Applied rewrites33.6%
Taylor expanded in b around inf
Applied rewrites42.2%
if 3.4000000000000002e-38 < t < 1.04999999999999993e44Initial program 29.3%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.6%
Taylor expanded in z around inf
Applied rewrites30.2%
Taylor expanded in y0 around inf
Applied rewrites53.5%
if 1.04999999999999993e44 < t Initial program 22.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.1%
Taylor expanded in b around inf
Applied rewrites56.8%
Final simplification50.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y2 -4.5e+260)
(* (* (* y2 y1) k) y4)
(if (<= y2 -1.4e+120)
(* (* y0 k) (fma b z (* (- y2) y5)))
(if (<= y2 -6.5e-8)
(* (fma c i (* (- b) a)) (* t z))
(if (<= y2 4.9e-31)
(* (* (fma j y4 (* (- z) a)) t) b)
(if (<= y2 6e+123)
(* (* (fma j y1 (* (- c) y)) i) x)
(* (* (fma k y2 (* (- j) y3)) y4) y1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y2 <= -4.5e+260) {
tmp = ((y2 * y1) * k) * y4;
} else if (y2 <= -1.4e+120) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else if (y2 <= -6.5e-8) {
tmp = fma(c, i, (-b * a)) * (t * z);
} else if (y2 <= 4.9e-31) {
tmp = (fma(j, y4, (-z * a)) * t) * b;
} else if (y2 <= 6e+123) {
tmp = (fma(j, y1, (-c * y)) * i) * x;
} else {
tmp = (fma(k, y2, (-j * y3)) * y4) * y1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y2 <= -4.5e+260) tmp = Float64(Float64(Float64(y2 * y1) * k) * y4); elseif (y2 <= -1.4e+120) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); elseif (y2 <= -6.5e-8) tmp = Float64(fma(c, i, Float64(Float64(-b) * a)) * Float64(t * z)); elseif (y2 <= 4.9e-31) tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); elseif (y2 <= 6e+123) tmp = Float64(Float64(fma(j, y1, Float64(Float64(-c) * y)) * i) * x); else tmp = Float64(Float64(fma(k, y2, Float64(Float64(-j) * y3)) * y4) * y1); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y2, -4.5e+260], N[(N[(N[(y2 * y1), $MachinePrecision] * k), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, -1.4e+120], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y2, -6.5e-8], N[(N[(c * i + N[((-b) * a), $MachinePrecision]), $MachinePrecision] * N[(t * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y2, 4.9e-31], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 6e+123], N[(N[(N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(k * y2 + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision] * y1), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y2 \leq -4.5 \cdot 10^{+260}:\\
\;\;\;\;\left(\left(y2 \cdot y1\right) \cdot k\right) \cdot y4\\
\mathbf{elif}\;y2 \leq -1.4 \cdot 10^{+120}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{elif}\;y2 \leq -6.5 \cdot 10^{-8}:\\
\;\;\;\;\mathsf{fma}\left(c, i, \left(-b\right) \cdot a\right) \cdot \left(t \cdot z\right)\\
\mathbf{elif}\;y2 \leq 4.9 \cdot 10^{-31}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\mathbf{elif}\;y2 \leq 6 \cdot 10^{+123}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right) \cdot i\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y2, \left(-j\right) \cdot y3\right) \cdot y4\right) \cdot y1\\
\end{array}
\end{array}
if y2 < -4.50000000000000023e260Initial program 0.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites33.3%
Taylor expanded in y1 around inf
Applied rewrites83.3%
Taylor expanded in k around inf
Applied rewrites100.0%
if -4.50000000000000023e260 < y2 < -1.4e120Initial program 16.9%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites37.3%
Taylor expanded in y0 around inf
Applied rewrites57.0%
if -1.4e120 < y2 < -6.49999999999999997e-8Initial program 41.1%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites31.9%
Taylor expanded in j around inf
Applied rewrites11.6%
Taylor expanded in z around inf
Applied rewrites45.6%
if -6.49999999999999997e-8 < y2 < 4.90000000000000023e-31Initial program 38.7%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.3%
Taylor expanded in b around inf
Applied rewrites39.8%
if 4.90000000000000023e-31 < y2 < 6.00000000000000016e123Initial program 32.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.9%
Taylor expanded in b around 0
Applied rewrites47.5%
Taylor expanded in i around inf
Applied rewrites47.7%
if 6.00000000000000016e123 < y2 Initial program 18.5%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.1%
Taylor expanded in y1 around inf
Applied rewrites59.6%
Final simplification48.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y2 -1.02e-41)
(* (fma (* j i) y1 (* (fma (- a) y1 (* y0 c)) y2)) x)
(if (<= y2 -1.85e-192)
(* (* (fma j t (* (- y) k)) b) y4)
(if (<= y2 1.05e-237)
(* (* (fma j x (* (- z) k)) (- y0)) b)
(if (<= y2 6.2e+80)
(* (* (- (* y0 k) (* a t)) z) b)
(* (* (- (* y2 c) (* j b)) y0) x))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y2 <= -1.02e-41) {
tmp = fma((j * i), y1, (fma(-a, y1, (y0 * c)) * y2)) * x;
} else if (y2 <= -1.85e-192) {
tmp = (fma(j, t, (-y * k)) * b) * y4;
} else if (y2 <= 1.05e-237) {
tmp = (fma(j, x, (-z * k)) * -y0) * b;
} else if (y2 <= 6.2e+80) {
tmp = (((y0 * k) - (a * t)) * z) * b;
} else {
tmp = (((y2 * c) - (j * b)) * y0) * x;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y2 <= -1.02e-41) tmp = Float64(fma(Float64(j * i), y1, Float64(fma(Float64(-a), y1, Float64(y0 * c)) * y2)) * x); elseif (y2 <= -1.85e-192) tmp = Float64(Float64(fma(j, t, Float64(Float64(-y) * k)) * b) * y4); elseif (y2 <= 1.05e-237) tmp = Float64(Float64(fma(j, x, Float64(Float64(-z) * k)) * Float64(-y0)) * b); elseif (y2 <= 6.2e+80) tmp = Float64(Float64(Float64(Float64(y0 * k) - Float64(a * t)) * z) * b); else tmp = Float64(Float64(Float64(Float64(y2 * c) - Float64(j * b)) * y0) * x); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y2, -1.02e-41], N[(N[(N[(j * i), $MachinePrecision] * y1 + N[(N[((-a) * y1 + N[(y0 * c), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y2, -1.85e-192], N[(N[(N[(j * t + N[((-y) * k), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y2, 1.05e-237], N[(N[(N[(j * x + N[((-z) * k), $MachinePrecision]), $MachinePrecision] * (-y0)), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[y2, 6.2e+80], N[(N[(N[(N[(y0 * k), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision] * b), $MachinePrecision], N[(N[(N[(N[(y2 * c), $MachinePrecision] - N[(j * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision] * x), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y2 \leq -1.02 \cdot 10^{-41}:\\
\;\;\;\;\mathsf{fma}\left(j \cdot i, y1, \mathsf{fma}\left(-a, y1, y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{elif}\;y2 \leq -1.85 \cdot 10^{-192}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, t, \left(-y\right) \cdot k\right) \cdot b\right) \cdot y4\\
\mathbf{elif}\;y2 \leq 1.05 \cdot 10^{-237}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, x, \left(-z\right) \cdot k\right) \cdot \left(-y0\right)\right) \cdot b\\
\mathbf{elif}\;y2 \leq 6.2 \cdot 10^{+80}:\\
\;\;\;\;\left(\left(y0 \cdot k - a \cdot t\right) \cdot z\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(\left(y2 \cdot c - j \cdot b\right) \cdot y0\right) \cdot x\\
\end{array}
\end{array}
if y2 < -1.02e-41Initial program 29.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.2%
Taylor expanded in b around 0
Applied rewrites48.5%
Taylor expanded in y around 0
Applied rewrites47.5%
if -1.02e-41 < y2 < -1.85e-192Initial program 43.4%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites65.5%
if -1.85e-192 < y2 < 1.0500000000000001e-237Initial program 37.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.0%
Taylor expanded in y0 around inf
Applied rewrites58.2%
if 1.0500000000000001e-237 < y2 < 6.19999999999999976e80Initial program 31.1%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites34.8%
Taylor expanded in z around inf
Applied rewrites38.9%
if 6.19999999999999976e80 < y2 Initial program 24.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.8%
Taylor expanded in y0 around inf
Applied rewrites60.3%
Final simplification51.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma y y5 (* (- z) y1)) i) k)))
(if (<= y4 -5.5e+100)
(* (* (fma k y2 (* (- j) y3)) y4) y1)
(if (<= y4 -5.2e-101)
t_1
(if (<= y4 2.15e-274)
(* (* (fma j y1 (* (- c) y)) i) x)
(if (<= y4 1.95e-13) t_1 (* (* (fma i z (* (- y4) y2)) c) t)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(y, y5, (-z * y1)) * i) * k;
double tmp;
if (y4 <= -5.5e+100) {
tmp = (fma(k, y2, (-j * y3)) * y4) * y1;
} else if (y4 <= -5.2e-101) {
tmp = t_1;
} else if (y4 <= 2.15e-274) {
tmp = (fma(j, y1, (-c * y)) * i) * x;
} else if (y4 <= 1.95e-13) {
tmp = t_1;
} else {
tmp = (fma(i, z, (-y4 * y2)) * c) * t;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(y, y5, Float64(Float64(-z) * y1)) * i) * k) tmp = 0.0 if (y4 <= -5.5e+100) tmp = Float64(Float64(fma(k, y2, Float64(Float64(-j) * y3)) * y4) * y1); elseif (y4 <= -5.2e-101) tmp = t_1; elseif (y4 <= 2.15e-274) tmp = Float64(Float64(fma(j, y1, Float64(Float64(-c) * y)) * i) * x); elseif (y4 <= 1.95e-13) tmp = t_1; else tmp = Float64(Float64(fma(i, z, Float64(Float64(-y4) * y2)) * c) * t); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(y * y5 + N[((-z) * y1), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * k), $MachinePrecision]}, If[LessEqual[y4, -5.5e+100], N[(N[(N[(k * y2 + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision] * y1), $MachinePrecision], If[LessEqual[y4, -5.2e-101], t$95$1, If[LessEqual[y4, 2.15e-274], N[(N[(N[(j * y1 + N[((-c) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[y4, 1.95e-13], t$95$1, N[(N[(N[(i * z + N[((-y4) * y2), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision] * t), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(y, y5, \left(-z\right) \cdot y1\right) \cdot i\right) \cdot k\\
\mathbf{if}\;y4 \leq -5.5 \cdot 10^{+100}:\\
\;\;\;\;\left(\mathsf{fma}\left(k, y2, \left(-j\right) \cdot y3\right) \cdot y4\right) \cdot y1\\
\mathbf{elif}\;y4 \leq -5.2 \cdot 10^{-101}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y4 \leq 2.15 \cdot 10^{-274}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y1, \left(-c\right) \cdot y\right) \cdot i\right) \cdot x\\
\mathbf{elif}\;y4 \leq 1.95 \cdot 10^{-13}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(i, z, \left(-y4\right) \cdot y2\right) \cdot c\right) \cdot t\\
\end{array}
\end{array}
if y4 < -5.5000000000000002e100Initial program 32.6%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites68.1%
Taylor expanded in y1 around inf
Applied rewrites55.7%
if -5.5000000000000002e100 < y4 < -5.2000000000000002e-101 or 2.14999999999999995e-274 < y4 < 1.95000000000000002e-13Initial program 32.9%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.7%
Taylor expanded in i around inf
Applied rewrites43.7%
if -5.2000000000000002e-101 < y4 < 2.14999999999999995e-274Initial program 28.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.5%
Taylor expanded in b around 0
Applied rewrites52.6%
Taylor expanded in i around inf
Applied rewrites44.8%
if 1.95000000000000002e-13 < y4 Initial program 30.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.5%
Taylor expanded in c around inf
Applied rewrites48.6%
Final simplification47.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= t -1.08e+158)
(* (* (fma y2 y5 (* (- z) b)) t) a)
(if (<= t -7.5e-72)
(* (* y0 k) (fma b z (* (- y2) y5)))
(if (<= t -1.68e-217)
(* (* (fma y0 y5 (* (- y1) y4)) y3) j)
(if (<= t 2.9e-38)
(* (fma a y (* (- j) y0)) (* b x))
(* (* (fma j y4 (* (- z) a)) t) b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -1.08e+158) {
tmp = (fma(y2, y5, (-z * b)) * t) * a;
} else if (t <= -7.5e-72) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else if (t <= -1.68e-217) {
tmp = (fma(y0, y5, (-y1 * y4)) * y3) * j;
} else if (t <= 2.9e-38) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else {
tmp = (fma(j, y4, (-z * a)) * t) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -1.08e+158) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a); elseif (t <= -7.5e-72) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); elseif (t <= -1.68e-217) tmp = Float64(Float64(fma(y0, y5, Float64(Float64(-y1) * y4)) * y3) * j); elseif (t <= 2.9e-38) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); else tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -1.08e+158], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, -7.5e-72], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.68e-217], N[(N[(N[(y0 * y5 + N[((-y1) * y4), $MachinePrecision]), $MachinePrecision] * y3), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[t, 2.9e-38], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.08 \cdot 10^{+158}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;t \leq -7.5 \cdot 10^{-72}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{elif}\;t \leq -1.68 \cdot 10^{-217}:\\
\;\;\;\;\left(\mathsf{fma}\left(y0, y5, \left(-y1\right) \cdot y4\right) \cdot y3\right) \cdot j\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{-38}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\end{array}
\end{array}
if t < -1.08e158Initial program 29.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.0%
Taylor expanded in a around inf
Applied rewrites57.3%
if -1.08e158 < t < -7.5000000000000004e-72Initial program 40.4%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites63.3%
Taylor expanded in y0 around inf
Applied rewrites43.8%
if -7.5000000000000004e-72 < t < -1.67999999999999995e-217Initial program 29.4%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.5%
Taylor expanded in j around inf
Applied rewrites41.9%
if -1.67999999999999995e-217 < t < 2.89999999999999994e-38Initial program 34.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.9%
Taylor expanded in b around 0
Applied rewrites33.6%
Taylor expanded in b around inf
Applied rewrites42.2%
if 2.89999999999999994e-38 < t Initial program 24.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.9%
Taylor expanded in b around inf
Applied rewrites49.4%
Final simplification46.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= t -8.5e+38)
(* (* (fma y2 y5 (* (- z) b)) t) a)
(if (<= t -5.6e-72)
(* (fma y0 z (* (- y) y4)) (* k b))
(if (<= t 2.9e-38)
(* (fma a y (* (- j) y0)) (* b x))
(* (* (fma j y4 (* (- z) a)) t) b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -8.5e+38) {
tmp = (fma(y2, y5, (-z * b)) * t) * a;
} else if (t <= -5.6e-72) {
tmp = fma(y0, z, (-y * y4)) * (k * b);
} else if (t <= 2.9e-38) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else {
tmp = (fma(j, y4, (-z * a)) * t) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -8.5e+38) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a); elseif (t <= -5.6e-72) tmp = Float64(fma(y0, z, Float64(Float64(-y) * y4)) * Float64(k * b)); elseif (t <= 2.9e-38) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); else tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -8.5e+38], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, -5.6e-72], N[(N[(y0 * z + N[((-y) * y4), $MachinePrecision]), $MachinePrecision] * N[(k * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.9e-38], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -8.5 \cdot 10^{+38}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;t \leq -5.6 \cdot 10^{-72}:\\
\;\;\;\;\mathsf{fma}\left(y0, z, \left(-y\right) \cdot y4\right) \cdot \left(k \cdot b\right)\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{-38}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\end{array}
\end{array}
if t < -8.4999999999999997e38Initial program 32.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.9%
Taylor expanded in a around inf
Applied rewrites46.8%
if -8.4999999999999997e38 < t < -5.5999999999999996e-72Initial program 44.2%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.6%
Taylor expanded in b around inf
Applied rewrites48.5%
if -5.5999999999999996e-72 < t < 2.89999999999999994e-38Initial program 32.7%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.5%
Taylor expanded in b around 0
Applied rewrites35.3%
Taylor expanded in b around inf
Applied rewrites35.8%
if 2.89999999999999994e-38 < t Initial program 24.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.9%
Taylor expanded in b around inf
Applied rewrites49.4%
Final simplification43.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= t -1.08e+158)
(* (* (fma y2 y5 (* (- z) b)) t) a)
(if (<= t 3.9e+40)
(* (* y0 k) (fma b z (* (- y2) y5)))
(* (* (fma j y4 (* (- z) a)) t) b))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -1.08e+158) {
tmp = (fma(y2, y5, (-z * b)) * t) * a;
} else if (t <= 3.9e+40) {
tmp = (y0 * k) * fma(b, z, (-y2 * y5));
} else {
tmp = (fma(j, y4, (-z * a)) * t) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -1.08e+158) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a); elseif (t <= 3.9e+40) tmp = Float64(Float64(y0 * k) * fma(b, z, Float64(Float64(-y2) * y5))); else tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -1.08e+158], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, 3.9e+40], N[(N[(y0 * k), $MachinePrecision] * N[(b * z + N[((-y2) * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.08 \cdot 10^{+158}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;t \leq 3.9 \cdot 10^{+40}:\\
\;\;\;\;\left(y0 \cdot k\right) \cdot \mathsf{fma}\left(b, z, \left(-y2\right) \cdot y5\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\end{array}
\end{array}
if t < -1.08e158Initial program 29.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.0%
Taylor expanded in a around inf
Applied rewrites57.3%
if -1.08e158 < t < 3.9000000000000001e40Initial program 34.4%
Taylor expanded in k around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.3%
Taylor expanded in y0 around inf
Applied rewrites35.7%
if 3.9000000000000001e40 < t Initial program 22.9%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.1%
Taylor expanded in b around inf
Applied rewrites56.8%
Final simplification43.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= t -2.5e+27)
(* (* (fma y2 y5 (* (- z) b)) t) a)
(if (<= t 2.9e-38)
(* (fma a y (* (- j) y0)) (* b x))
(* (* (fma j y4 (* (- z) a)) t) b))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (t <= -2.5e+27) {
tmp = (fma(y2, y5, (-z * b)) * t) * a;
} else if (t <= 2.9e-38) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else {
tmp = (fma(j, y4, (-z * a)) * t) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (t <= -2.5e+27) tmp = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a); elseif (t <= 2.9e-38) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); else tmp = Float64(Float64(fma(j, y4, Float64(Float64(-z) * a)) * t) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[t, -2.5e+27], N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision], If[LessEqual[t, 2.9e-38], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(j * y4 + N[((-z) * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2.5 \cdot 10^{+27}:\\
\;\;\;\;\left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{elif}\;t \leq 2.9 \cdot 10^{-38}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(j, y4, \left(-z\right) \cdot a\right) \cdot t\right) \cdot b\\
\end{array}
\end{array}
if t < -2.4999999999999999e27Initial program 35.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.1%
Taylor expanded in a around inf
Applied rewrites45.5%
if -2.4999999999999999e27 < t < 2.89999999999999994e-38Initial program 33.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.0%
Taylor expanded in b around 0
Applied rewrites34.3%
Taylor expanded in b around inf
Applied rewrites34.7%
if 2.89999999999999994e-38 < t Initial program 24.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.9%
Taylor expanded in b around inf
Applied rewrites49.4%
Final simplification41.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (fma y2 y5 (* (- z) b)) t) a)))
(if (<= t -2.5e+27)
t_1
(if (<= t 1e+72) (* (fma a y (* (- j) y0)) (* b x)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (fma(y2, y5, (-z * b)) * t) * a;
double tmp;
if (t <= -2.5e+27) {
tmp = t_1;
} else if (t <= 1e+72) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(fma(y2, y5, Float64(Float64(-z) * b)) * t) * a) tmp = 0.0 if (t <= -2.5e+27) tmp = t_1; elseif (t <= 1e+72) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(y2 * y5 + N[((-z) * b), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] * a), $MachinePrecision]}, If[LessEqual[t, -2.5e+27], t$95$1, If[LessEqual[t, 1e+72], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(y2, y5, \left(-z\right) \cdot b\right) \cdot t\right) \cdot a\\
\mathbf{if}\;t \leq -2.5 \cdot 10^{+27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 10^{+72}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.4999999999999999e27 or 9.99999999999999944e71 < t Initial program 28.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in a around inf
Applied rewrites42.6%
if -2.4999999999999999e27 < t < 9.99999999999999944e71Initial program 33.3%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.6%
Taylor expanded in b around 0
Applied rewrites35.5%
Taylor expanded in b around inf
Applied rewrites33.2%
Final simplification37.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (* (- z) y0) c) y3)))
(if (<= z -2.1e+189)
t_1
(if (<= z 6.2e+73) (* (fma a y (* (- j) y0)) (* b x)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((-z * y0) * c) * y3;
double tmp;
if (z <= -2.1e+189) {
tmp = t_1;
} else if (z <= 6.2e+73) {
tmp = fma(a, y, (-j * y0)) * (b * x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(Float64(-z) * y0) * c) * y3) tmp = 0.0 if (z <= -2.1e+189) tmp = t_1; elseif (z <= 6.2e+73) tmp = Float64(fma(a, y, Float64(Float64(-j) * y0)) * Float64(b * x)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[((-z) * y0), $MachinePrecision] * c), $MachinePrecision] * y3), $MachinePrecision]}, If[LessEqual[z, -2.1e+189], t$95$1, If[LessEqual[z, 6.2e+73], N[(N[(a * y + N[((-j) * y0), $MachinePrecision]), $MachinePrecision] * N[(b * x), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(\left(-z\right) \cdot y0\right) \cdot c\right) \cdot y3\\
\mathbf{if}\;z \leq -2.1 \cdot 10^{+189}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{+73}:\\
\;\;\;\;\mathsf{fma}\left(a, y, \left(-j\right) \cdot y0\right) \cdot \left(b \cdot x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.09999999999999992e189 or 6.1999999999999999e73 < z Initial program 29.6%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.4%
Taylor expanded in z around inf
Applied rewrites54.5%
Taylor expanded in c around inf
Applied rewrites46.9%
if -2.09999999999999992e189 < z < 6.1999999999999999e73Initial program 32.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.2%
Taylor expanded in b around 0
Applied rewrites37.3%
Taylor expanded in b around inf
Applied rewrites29.0%
Final simplification34.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= j -5.4e+64)
(* (* (* (- j) y0) b) x)
(if (<= j -6.9e-301)
(* (* (* y2 y1) k) y4)
(if (<= j 9.2e+157) (* (* (* y0 c) y2) x) (* (* (* j b) y4) t)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (j <= -5.4e+64) {
tmp = ((-j * y0) * b) * x;
} else if (j <= -6.9e-301) {
tmp = ((y2 * y1) * k) * y4;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = ((j * b) * y4) * t;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: tmp
if (j <= (-5.4d+64)) then
tmp = ((-j * y0) * b) * x
else if (j <= (-6.9d-301)) then
tmp = ((y2 * y1) * k) * y4
else if (j <= 9.2d+157) then
tmp = ((y0 * c) * y2) * x
else
tmp = ((j * b) * y4) * t
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (j <= -5.4e+64) {
tmp = ((-j * y0) * b) * x;
} else if (j <= -6.9e-301) {
tmp = ((y2 * y1) * k) * y4;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = ((j * b) * y4) * t;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if j <= -5.4e+64: tmp = ((-j * y0) * b) * x elif j <= -6.9e-301: tmp = ((y2 * y1) * k) * y4 elif j <= 9.2e+157: tmp = ((y0 * c) * y2) * x else: tmp = ((j * b) * y4) * t return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (j <= -5.4e+64) tmp = Float64(Float64(Float64(Float64(-j) * y0) * b) * x); elseif (j <= -6.9e-301) tmp = Float64(Float64(Float64(y2 * y1) * k) * y4); elseif (j <= 9.2e+157) tmp = Float64(Float64(Float64(y0 * c) * y2) * x); else tmp = Float64(Float64(Float64(j * b) * y4) * t); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0; if (j <= -5.4e+64) tmp = ((-j * y0) * b) * x; elseif (j <= -6.9e-301) tmp = ((y2 * y1) * k) * y4; elseif (j <= 9.2e+157) tmp = ((y0 * c) * y2) * x; else tmp = ((j * b) * y4) * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[j, -5.4e+64], N[(N[(N[((-j) * y0), $MachinePrecision] * b), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[j, -6.9e-301], N[(N[(N[(y2 * y1), $MachinePrecision] * k), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[j, 9.2e+157], N[(N[(N[(y0 * c), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], N[(N[(N[(j * b), $MachinePrecision] * y4), $MachinePrecision] * t), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -5.4 \cdot 10^{+64}:\\
\;\;\;\;\left(\left(\left(-j\right) \cdot y0\right) \cdot b\right) \cdot x\\
\mathbf{elif}\;j \leq -6.9 \cdot 10^{-301}:\\
\;\;\;\;\left(\left(y2 \cdot y1\right) \cdot k\right) \cdot y4\\
\mathbf{elif}\;j \leq 9.2 \cdot 10^{+157}:\\
\;\;\;\;\left(\left(y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(j \cdot b\right) \cdot y4\right) \cdot t\\
\end{array}
\end{array}
if j < -5.3999999999999999e64Initial program 21.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.3%
Taylor expanded in y around 0
Applied rewrites53.6%
Taylor expanded in b around inf
Applied rewrites56.0%
if -5.3999999999999999e64 < j < -6.8999999999999997e-301Initial program 32.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in y1 around inf
Applied rewrites28.8%
Taylor expanded in k around inf
Applied rewrites25.1%
if -6.8999999999999997e-301 < j < 9.20000000000000015e157Initial program 38.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.5%
Taylor expanded in b around 0
Applied rewrites39.7%
Taylor expanded in y0 around inf
Applied rewrites25.6%
if 9.20000000000000015e157 < j Initial program 21.4%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.6%
Taylor expanded in j around inf
Applied rewrites58.3%
Taylor expanded in b around inf
Applied rewrites54.3%
Final simplification34.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (* j b) y4) t)))
(if (<= j -2.35e+67)
t_1
(if (<= j -6.9e-301)
(* (* (* y2 y1) k) y4)
(if (<= j 9.2e+157) (* (* (* y0 c) y2) x) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((j * b) * y4) * t;
double tmp;
if (j <= -2.35e+67) {
tmp = t_1;
} else if (j <= -6.9e-301) {
tmp = ((y2 * y1) * k) * y4;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = ((j * b) * y4) * t
if (j <= (-2.35d+67)) then
tmp = t_1
else if (j <= (-6.9d-301)) then
tmp = ((y2 * y1) * k) * y4
else if (j <= 9.2d+157) then
tmp = ((y0 * c) * y2) * x
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((j * b) * y4) * t;
double tmp;
if (j <= -2.35e+67) {
tmp = t_1;
} else if (j <= -6.9e-301) {
tmp = ((y2 * y1) * k) * y4;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = ((j * b) * y4) * t tmp = 0 if j <= -2.35e+67: tmp = t_1 elif j <= -6.9e-301: tmp = ((y2 * y1) * k) * y4 elif j <= 9.2e+157: tmp = ((y0 * c) * y2) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(j * b) * y4) * t) tmp = 0.0 if (j <= -2.35e+67) tmp = t_1; elseif (j <= -6.9e-301) tmp = Float64(Float64(Float64(y2 * y1) * k) * y4); elseif (j <= 9.2e+157) tmp = Float64(Float64(Float64(y0 * c) * y2) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = ((j * b) * y4) * t; tmp = 0.0; if (j <= -2.35e+67) tmp = t_1; elseif (j <= -6.9e-301) tmp = ((y2 * y1) * k) * y4; elseif (j <= 9.2e+157) tmp = ((y0 * c) * y2) * x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * b), $MachinePrecision] * y4), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[j, -2.35e+67], t$95$1, If[LessEqual[j, -6.9e-301], N[(N[(N[(y2 * y1), $MachinePrecision] * k), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[j, 9.2e+157], N[(N[(N[(y0 * c), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(j \cdot b\right) \cdot y4\right) \cdot t\\
\mathbf{if}\;j \leq -2.35 \cdot 10^{+67}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -6.9 \cdot 10^{-301}:\\
\;\;\;\;\left(\left(y2 \cdot y1\right) \cdot k\right) \cdot y4\\
\mathbf{elif}\;j \leq 9.2 \cdot 10^{+157}:\\
\;\;\;\;\left(\left(y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.35000000000000009e67 or 9.20000000000000015e157 < j Initial program 21.5%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.2%
Taylor expanded in j around inf
Applied rewrites48.8%
Taylor expanded in b around inf
Applied rewrites47.5%
if -2.35000000000000009e67 < j < -6.8999999999999997e-301Initial program 32.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.7%
Taylor expanded in y1 around inf
Applied rewrites28.8%
Taylor expanded in k around inf
Applied rewrites25.1%
if -6.8999999999999997e-301 < j < 9.20000000000000015e157Initial program 38.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.5%
Taylor expanded in b around 0
Applied rewrites39.7%
Taylor expanded in y0 around inf
Applied rewrites25.6%
Final simplification32.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (let* ((t_1 (* (* (* j b) y4) t))) (if (<= j -2.75e+26) t_1 (if (<= j 9.2e+157) (* (* (* y0 c) y2) x) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((j * b) * y4) * t;
double tmp;
if (j <= -2.75e+26) {
tmp = t_1;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = ((j * b) * y4) * t
if (j <= (-2.75d+26)) then
tmp = t_1
else if (j <= 9.2d+157) then
tmp = ((y0 * c) * y2) * x
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((j * b) * y4) * t;
double tmp;
if (j <= -2.75e+26) {
tmp = t_1;
} else if (j <= 9.2e+157) {
tmp = ((y0 * c) * y2) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = ((j * b) * y4) * t tmp = 0 if j <= -2.75e+26: tmp = t_1 elif j <= 9.2e+157: tmp = ((y0 * c) * y2) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(j * b) * y4) * t) tmp = 0.0 if (j <= -2.75e+26) tmp = t_1; elseif (j <= 9.2e+157) tmp = Float64(Float64(Float64(y0 * c) * y2) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = ((j * b) * y4) * t; tmp = 0.0; if (j <= -2.75e+26) tmp = t_1; elseif (j <= 9.2e+157) tmp = ((y0 * c) * y2) * x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(j * b), $MachinePrecision] * y4), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[j, -2.75e+26], t$95$1, If[LessEqual[j, 9.2e+157], N[(N[(N[(y0 * c), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(j \cdot b\right) \cdot y4\right) \cdot t\\
\mathbf{if}\;j \leq -2.75 \cdot 10^{+26}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 9.2 \cdot 10^{+157}:\\
\;\;\;\;\left(\left(y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -2.7499999999999998e26 or 9.20000000000000015e157 < j Initial program 21.2%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.5%
Taylor expanded in j around inf
Applied rewrites46.7%
Taylor expanded in b around inf
Applied rewrites45.5%
if -2.7499999999999998e26 < j < 9.20000000000000015e157Initial program 36.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites34.5%
Taylor expanded in b around 0
Applied rewrites34.3%
Taylor expanded in y0 around inf
Applied rewrites22.2%
Final simplification29.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (let* ((t_1 (* (* (* y0 c) y2) x))) (if (<= c -6.5e+95) t_1 (if (<= c 3.9e-10) (* (* (* j i) y1) x) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((y0 * c) * y2) * x;
double tmp;
if (c <= -6.5e+95) {
tmp = t_1;
} else if (c <= 3.9e-10) {
tmp = ((j * i) * y1) * x;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = ((y0 * c) * y2) * x
if (c <= (-6.5d+95)) then
tmp = t_1
else if (c <= 3.9d-10) then
tmp = ((j * i) * y1) * x
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((y0 * c) * y2) * x;
double tmp;
if (c <= -6.5e+95) {
tmp = t_1;
} else if (c <= 3.9e-10) {
tmp = ((j * i) * y1) * x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = ((y0 * c) * y2) * x tmp = 0 if c <= -6.5e+95: tmp = t_1 elif c <= 3.9e-10: tmp = ((j * i) * y1) * x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(y0 * c) * y2) * x) tmp = 0.0 if (c <= -6.5e+95) tmp = t_1; elseif (c <= 3.9e-10) tmp = Float64(Float64(Float64(j * i) * y1) * x); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = ((y0 * c) * y2) * x; tmp = 0.0; if (c <= -6.5e+95) tmp = t_1; elseif (c <= 3.9e-10) tmp = ((j * i) * y1) * x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(y0 * c), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[c, -6.5e+95], t$95$1, If[LessEqual[c, 3.9e-10], N[(N[(N[(j * i), $MachinePrecision] * y1), $MachinePrecision] * x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{if}\;c \leq -6.5 \cdot 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 3.9 \cdot 10^{-10}:\\
\;\;\;\;\left(\left(j \cdot i\right) \cdot y1\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -6.5e95 or 3.9e-10 < c Initial program 24.8%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.2%
Taylor expanded in b around 0
Applied rewrites47.6%
Taylor expanded in y0 around inf
Applied rewrites35.9%
if -6.5e95 < c < 3.9e-10Initial program 36.5%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.0%
Taylor expanded in b around 0
Applied rewrites29.0%
Taylor expanded in j around inf
Applied rewrites20.3%
Final simplification27.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (let* ((t_1 (* (* (* y0 c) y2) x))) (if (<= c -1.42e+81) t_1 (if (<= c 6e+62) (* (* (* y5 y3) y0) j) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((y0 * c) * y2) * x;
double tmp;
if (c <= -1.42e+81) {
tmp = t_1;
} else if (c <= 6e+62) {
tmp = ((y5 * y3) * y0) * j;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: tmp
t_1 = ((y0 * c) * y2) * x
if (c <= (-1.42d+81)) then
tmp = t_1
else if (c <= 6d+62) then
tmp = ((y5 * y3) * y0) * 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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = ((y0 * c) * y2) * x;
double tmp;
if (c <= -1.42e+81) {
tmp = t_1;
} else if (c <= 6e+62) {
tmp = ((y5 * y3) * y0) * j;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = ((y0 * c) * y2) * x tmp = 0 if c <= -1.42e+81: tmp = t_1 elif c <= 6e+62: tmp = ((y5 * y3) * y0) * j else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(Float64(y0 * c) * y2) * x) tmp = 0.0 if (c <= -1.42e+81) tmp = t_1; elseif (c <= 6e+62) tmp = Float64(Float64(Float64(y5 * y3) * y0) * j); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = ((y0 * c) * y2) * x; tmp = 0.0; if (c <= -1.42e+81) tmp = t_1; elseif (c <= 6e+62) tmp = ((y5 * y3) * y0) * j; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(N[(y0 * c), $MachinePrecision] * y2), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[c, -1.42e+81], t$95$1, If[LessEqual[c, 6e+62], N[(N[(N[(y5 * y3), $MachinePrecision] * y0), $MachinePrecision] * j), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(y0 \cdot c\right) \cdot y2\right) \cdot x\\
\mathbf{if}\;c \leq -1.42 \cdot 10^{+81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 6 \cdot 10^{+62}:\\
\;\;\;\;\left(\left(y5 \cdot y3\right) \cdot y0\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -1.41999999999999998e81 or 6e62 < c Initial program 25.2%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.7%
Taylor expanded in b around 0
Applied rewrites45.4%
Taylor expanded in y0 around inf
Applied rewrites36.8%
if -1.41999999999999998e81 < c < 6e62Initial program 35.7%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites40.8%
Taylor expanded in j around inf
Applied rewrites24.7%
Taylor expanded in y0 around inf
Applied rewrites17.5%
Final simplification25.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (* (* (* y5 y3) y0) j))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return ((y5 * y3) * y0) * j;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
code = ((y5 * y3) * y0) * 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, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return ((y5 * y3) * y0) * j;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return ((y5 * y3) * y0) * j
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(Float64(y5 * y3) * y0) * j) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = ((y5 * y3) * y0) * j; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(N[(y5 * y3), $MachinePrecision] * y0), $MachinePrecision] * j), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(y5 \cdot y3\right) \cdot y0\right) \cdot j
\end{array}
Initial program 31.3%
Taylor expanded in y3 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites37.6%
Taylor expanded in j around inf
Applied rewrites25.8%
Taylor expanded in y0 around inf
Applied rewrites16.7%
Final simplification16.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* y4 c) (* y5 a)))
(t_2 (- (* x y2) (* z y3)))
(t_3 (- (* y2 t) (* y3 y)))
(t_4 (- (* k y2) (* j y3)))
(t_5 (- (* y4 b) (* y5 i)))
(t_6 (* (- (* j t) (* k y)) t_5))
(t_7 (- (* b a) (* i c)))
(t_8 (* t_7 (- (* y x) (* t z))))
(t_9 (- (* j x) (* k z)))
(t_10 (* (- (* b y0) (* i y1)) t_9))
(t_11 (* t_9 (- (* y0 b) (* i y1))))
(t_12 (- (* y4 y1) (* y5 y0)))
(t_13 (* t_4 t_12))
(t_14 (* (- (* y2 k) (* y3 j)) t_12))
(t_15
(+
(-
(-
(- (* (* k y) (* y5 i)) (* (* y b) (* y4 k)))
(* (* y5 t) (* i j)))
(- (* t_3 t_1) t_14))
(- t_8 (- t_11 (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))))
(t_16
(+
(+
(- t_6 (* (* y3 y) (- (* y5 a) (* y4 c))))
(+ (* (* y5 a) (* t y2)) t_13))
(-
(* t_2 (- (* c y0) (* a y1)))
(- t_10 (* (- (* y x) (* z t)) t_7)))))
(t_17 (- (* t y2) (* y y3))))
(if (< y4 -7.206256231996481e+60)
(- (- t_8 (- t_11 t_6)) (- (/ t_3 (/ 1.0 t_1)) t_14))
(if (< y4 -3.364603505246317e-66)
(+
(-
(- (- (* (* t c) (* i z)) (* (* a t) (* b z))) (* (* y c) (* i x)))
t_10)
(-
(* (- (* y0 c) (* a y1)) t_2)
(- (* t_17 (- (* y4 c) (* a y5))) (* (- (* y1 y4) (* y5 y0)) t_4))))
(if (< y4 -1.2000065055686116e-105)
t_16
(if (< y4 6.718963124057495e-279)
t_15
(if (< y4 4.77962681403792e-222)
t_16
(if (< y4 2.2852241541266835e-175)
t_15
(+
(-
(+
(+
(-
(* (- (* x y) (* z t)) (- (* a b) (* c i)))
(-
(* k (* i (* z y1)))
(+ (* j (* i (* x y1))) (* y0 (* k (* z b))))))
(-
(* z (* y3 (* a y1)))
(+ (* y2 (* x (* a y1))) (* y0 (* z (* c y3))))))
(* (- (* t j) (* y k)) t_5))
(* t_17 t_1))
t_13)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (y4 * c) - (y5 * a);
double t_2 = (x * y2) - (z * y3);
double t_3 = (y2 * t) - (y3 * y);
double t_4 = (k * y2) - (j * y3);
double t_5 = (y4 * b) - (y5 * i);
double t_6 = ((j * t) - (k * y)) * t_5;
double t_7 = (b * a) - (i * c);
double t_8 = t_7 * ((y * x) - (t * z));
double t_9 = (j * x) - (k * z);
double t_10 = ((b * y0) - (i * y1)) * t_9;
double t_11 = t_9 * ((y0 * b) - (i * y1));
double t_12 = (y4 * y1) - (y5 * y0);
double t_13 = t_4 * t_12;
double t_14 = ((y2 * k) - (y3 * j)) * t_12;
double t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))));
double t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)));
double t_17 = (t * y2) - (y * y3);
double tmp;
if (y4 < -7.206256231996481e+60) {
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14);
} else if (y4 < -3.364603505246317e-66) {
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)));
} else if (y4 < -1.2000065055686116e-105) {
tmp = t_16;
} else if (y4 < 6.718963124057495e-279) {
tmp = t_15;
} else if (y4 < 4.77962681403792e-222) {
tmp = t_16;
} else if (y4 < 2.2852241541266835e-175) {
tmp = t_15;
} else {
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5)
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), intent (in) :: k
real(8), intent (in) :: y0
real(8), intent (in) :: y1
real(8), intent (in) :: y2
real(8), intent (in) :: y3
real(8), intent (in) :: y4
real(8), intent (in) :: y5
real(8) :: t_1
real(8) :: t_10
real(8) :: t_11
real(8) :: t_12
real(8) :: t_13
real(8) :: t_14
real(8) :: t_15
real(8) :: t_16
real(8) :: t_17
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: t_6
real(8) :: t_7
real(8) :: t_8
real(8) :: t_9
real(8) :: tmp
t_1 = (y4 * c) - (y5 * a)
t_2 = (x * y2) - (z * y3)
t_3 = (y2 * t) - (y3 * y)
t_4 = (k * y2) - (j * y3)
t_5 = (y4 * b) - (y5 * i)
t_6 = ((j * t) - (k * y)) * t_5
t_7 = (b * a) - (i * c)
t_8 = t_7 * ((y * x) - (t * z))
t_9 = (j * x) - (k * z)
t_10 = ((b * y0) - (i * y1)) * t_9
t_11 = t_9 * ((y0 * b) - (i * y1))
t_12 = (y4 * y1) - (y5 * y0)
t_13 = t_4 * t_12
t_14 = ((y2 * k) - (y3 * j)) * t_12
t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))))
t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)))
t_17 = (t * y2) - (y * y3)
if (y4 < (-7.206256231996481d+60)) then
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0d0 / t_1)) - t_14)
else if (y4 < (-3.364603505246317d-66)) then
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)))
else if (y4 < (-1.2000065055686116d-105)) then
tmp = t_16
else if (y4 < 6.718963124057495d-279) then
tmp = t_15
else if (y4 < 4.77962681403792d-222) then
tmp = t_16
else if (y4 < 2.2852241541266835d-175) then
tmp = t_15
else
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13
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 k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (y4 * c) - (y5 * a);
double t_2 = (x * y2) - (z * y3);
double t_3 = (y2 * t) - (y3 * y);
double t_4 = (k * y2) - (j * y3);
double t_5 = (y4 * b) - (y5 * i);
double t_6 = ((j * t) - (k * y)) * t_5;
double t_7 = (b * a) - (i * c);
double t_8 = t_7 * ((y * x) - (t * z));
double t_9 = (j * x) - (k * z);
double t_10 = ((b * y0) - (i * y1)) * t_9;
double t_11 = t_9 * ((y0 * b) - (i * y1));
double t_12 = (y4 * y1) - (y5 * y0);
double t_13 = t_4 * t_12;
double t_14 = ((y2 * k) - (y3 * j)) * t_12;
double t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a)))));
double t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7)));
double t_17 = (t * y2) - (y * y3);
double tmp;
if (y4 < -7.206256231996481e+60) {
tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14);
} else if (y4 < -3.364603505246317e-66) {
tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4)));
} else if (y4 < -1.2000065055686116e-105) {
tmp = t_16;
} else if (y4 < 6.718963124057495e-279) {
tmp = t_15;
} else if (y4 < 4.77962681403792e-222) {
tmp = t_16;
} else if (y4 < 2.2852241541266835e-175) {
tmp = t_15;
} else {
tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): t_1 = (y4 * c) - (y5 * a) t_2 = (x * y2) - (z * y3) t_3 = (y2 * t) - (y3 * y) t_4 = (k * y2) - (j * y3) t_5 = (y4 * b) - (y5 * i) t_6 = ((j * t) - (k * y)) * t_5 t_7 = (b * a) - (i * c) t_8 = t_7 * ((y * x) - (t * z)) t_9 = (j * x) - (k * z) t_10 = ((b * y0) - (i * y1)) * t_9 t_11 = t_9 * ((y0 * b) - (i * y1)) t_12 = (y4 * y1) - (y5 * y0) t_13 = t_4 * t_12 t_14 = ((y2 * k) - (y3 * j)) * t_12 t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a))))) t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7))) t_17 = (t * y2) - (y * y3) tmp = 0 if y4 < -7.206256231996481e+60: tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14) elif y4 < -3.364603505246317e-66: tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4))) elif y4 < -1.2000065055686116e-105: tmp = t_16 elif y4 < 6.718963124057495e-279: tmp = t_15 elif y4 < 4.77962681403792e-222: tmp = t_16 elif y4 < 2.2852241541266835e-175: tmp = t_15 else: tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(y4 * c) - Float64(y5 * a)) t_2 = Float64(Float64(x * y2) - Float64(z * y3)) t_3 = Float64(Float64(y2 * t) - Float64(y3 * y)) t_4 = Float64(Float64(k * y2) - Float64(j * y3)) t_5 = Float64(Float64(y4 * b) - Float64(y5 * i)) t_6 = Float64(Float64(Float64(j * t) - Float64(k * y)) * t_5) t_7 = Float64(Float64(b * a) - Float64(i * c)) t_8 = Float64(t_7 * Float64(Float64(y * x) - Float64(t * z))) t_9 = Float64(Float64(j * x) - Float64(k * z)) t_10 = Float64(Float64(Float64(b * y0) - Float64(i * y1)) * t_9) t_11 = Float64(t_9 * Float64(Float64(y0 * b) - Float64(i * y1))) t_12 = Float64(Float64(y4 * y1) - Float64(y5 * y0)) t_13 = Float64(t_4 * t_12) t_14 = Float64(Float64(Float64(y2 * k) - Float64(y3 * j)) * t_12) t_15 = Float64(Float64(Float64(Float64(Float64(Float64(k * y) * Float64(y5 * i)) - Float64(Float64(y * b) * Float64(y4 * k))) - Float64(Float64(y5 * t) * Float64(i * j))) - Float64(Float64(t_3 * t_1) - t_14)) + Float64(t_8 - Float64(t_11 - Float64(Float64(Float64(y2 * x) - Float64(y3 * z)) * Float64(Float64(c * y0) - Float64(y1 * a)))))) t_16 = Float64(Float64(Float64(t_6 - Float64(Float64(y3 * y) * Float64(Float64(y5 * a) - Float64(y4 * c)))) + Float64(Float64(Float64(y5 * a) * Float64(t * y2)) + t_13)) + Float64(Float64(t_2 * Float64(Float64(c * y0) - Float64(a * y1))) - Float64(t_10 - Float64(Float64(Float64(y * x) - Float64(z * t)) * t_7)))) t_17 = Float64(Float64(t * y2) - Float64(y * y3)) tmp = 0.0 if (y4 < -7.206256231996481e+60) tmp = Float64(Float64(t_8 - Float64(t_11 - t_6)) - Float64(Float64(t_3 / Float64(1.0 / t_1)) - t_14)); elseif (y4 < -3.364603505246317e-66) tmp = Float64(Float64(Float64(Float64(Float64(Float64(t * c) * Float64(i * z)) - Float64(Float64(a * t) * Float64(b * z))) - Float64(Float64(y * c) * Float64(i * x))) - t_10) + Float64(Float64(Float64(Float64(y0 * c) - Float64(a * y1)) * t_2) - Float64(Float64(t_17 * Float64(Float64(y4 * c) - Float64(a * y5))) - Float64(Float64(Float64(y1 * y4) - Float64(y5 * y0)) * t_4)))); elseif (y4 < -1.2000065055686116e-105) tmp = t_16; elseif (y4 < 6.718963124057495e-279) tmp = t_15; elseif (y4 < 4.77962681403792e-222) tmp = t_16; elseif (y4 < 2.2852241541266835e-175) tmp = t_15; else tmp = Float64(Float64(Float64(Float64(Float64(Float64(Float64(Float64(x * y) - Float64(z * t)) * Float64(Float64(a * b) - Float64(c * i))) - Float64(Float64(k * Float64(i * Float64(z * y1))) - Float64(Float64(j * Float64(i * Float64(x * y1))) + Float64(y0 * Float64(k * Float64(z * b)))))) + Float64(Float64(z * Float64(y3 * Float64(a * y1))) - Float64(Float64(y2 * Float64(x * Float64(a * y1))) + Float64(y0 * Float64(z * Float64(c * y3)))))) + Float64(Float64(Float64(t * j) - Float64(y * k)) * t_5)) - Float64(t_17 * t_1)) + t_13); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = (y4 * c) - (y5 * a); t_2 = (x * y2) - (z * y3); t_3 = (y2 * t) - (y3 * y); t_4 = (k * y2) - (j * y3); t_5 = (y4 * b) - (y5 * i); t_6 = ((j * t) - (k * y)) * t_5; t_7 = (b * a) - (i * c); t_8 = t_7 * ((y * x) - (t * z)); t_9 = (j * x) - (k * z); t_10 = ((b * y0) - (i * y1)) * t_9; t_11 = t_9 * ((y0 * b) - (i * y1)); t_12 = (y4 * y1) - (y5 * y0); t_13 = t_4 * t_12; t_14 = ((y2 * k) - (y3 * j)) * t_12; t_15 = (((((k * y) * (y5 * i)) - ((y * b) * (y4 * k))) - ((y5 * t) * (i * j))) - ((t_3 * t_1) - t_14)) + (t_8 - (t_11 - (((y2 * x) - (y3 * z)) * ((c * y0) - (y1 * a))))); t_16 = ((t_6 - ((y3 * y) * ((y5 * a) - (y4 * c)))) + (((y5 * a) * (t * y2)) + t_13)) + ((t_2 * ((c * y0) - (a * y1))) - (t_10 - (((y * x) - (z * t)) * t_7))); t_17 = (t * y2) - (y * y3); tmp = 0.0; if (y4 < -7.206256231996481e+60) tmp = (t_8 - (t_11 - t_6)) - ((t_3 / (1.0 / t_1)) - t_14); elseif (y4 < -3.364603505246317e-66) tmp = (((((t * c) * (i * z)) - ((a * t) * (b * z))) - ((y * c) * (i * x))) - t_10) + ((((y0 * c) - (a * y1)) * t_2) - ((t_17 * ((y4 * c) - (a * y5))) - (((y1 * y4) - (y5 * y0)) * t_4))); elseif (y4 < -1.2000065055686116e-105) tmp = t_16; elseif (y4 < 6.718963124057495e-279) tmp = t_15; elseif (y4 < 4.77962681403792e-222) tmp = t_16; elseif (y4 < 2.2852241541266835e-175) tmp = t_15; else tmp = (((((((x * y) - (z * t)) * ((a * b) - (c * i))) - ((k * (i * (z * y1))) - ((j * (i * (x * y1))) + (y0 * (k * (z * b)))))) + ((z * (y3 * (a * y1))) - ((y2 * (x * (a * y1))) + (y0 * (z * (c * y3)))))) + (((t * j) - (y * k)) * t_5)) - (t_17 * t_1)) + t_13; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(y4 * c), $MachinePrecision] - N[(y5 * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(y2 * t), $MachinePrecision] - N[(y3 * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(y4 * b), $MachinePrecision] - N[(y5 * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(N[(j * t), $MachinePrecision] - N[(k * y), $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision]}, Block[{t$95$7 = N[(N[(b * a), $MachinePrecision] - N[(i * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$8 = N[(t$95$7 * N[(N[(y * x), $MachinePrecision] - N[(t * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$9 = N[(N[(j * x), $MachinePrecision] - N[(k * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$10 = N[(N[(N[(b * y0), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision] * t$95$9), $MachinePrecision]}, Block[{t$95$11 = N[(t$95$9 * N[(N[(y0 * b), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$12 = N[(N[(y4 * y1), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$13 = N[(t$95$4 * t$95$12), $MachinePrecision]}, Block[{t$95$14 = N[(N[(N[(y2 * k), $MachinePrecision] - N[(y3 * j), $MachinePrecision]), $MachinePrecision] * t$95$12), $MachinePrecision]}, Block[{t$95$15 = N[(N[(N[(N[(N[(N[(k * y), $MachinePrecision] * N[(y5 * i), $MachinePrecision]), $MachinePrecision] - N[(N[(y * b), $MachinePrecision] * N[(y4 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y5 * t), $MachinePrecision] * N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(t$95$3 * t$95$1), $MachinePrecision] - t$95$14), $MachinePrecision]), $MachinePrecision] + N[(t$95$8 - N[(t$95$11 - N[(N[(N[(y2 * x), $MachinePrecision] - N[(y3 * z), $MachinePrecision]), $MachinePrecision] * N[(N[(c * y0), $MachinePrecision] - N[(y1 * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$16 = N[(N[(N[(t$95$6 - N[(N[(y3 * y), $MachinePrecision] * N[(N[(y5 * a), $MachinePrecision] - N[(y4 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y5 * a), $MachinePrecision] * N[(t * y2), $MachinePrecision]), $MachinePrecision] + t$95$13), $MachinePrecision]), $MachinePrecision] + N[(N[(t$95$2 * N[(N[(c * y0), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(t$95$10 - N[(N[(N[(y * x), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * t$95$7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$17 = N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]}, If[Less[y4, -7.206256231996481e+60], N[(N[(t$95$8 - N[(t$95$11 - t$95$6), $MachinePrecision]), $MachinePrecision] - N[(N[(t$95$3 / N[(1.0 / t$95$1), $MachinePrecision]), $MachinePrecision] - t$95$14), $MachinePrecision]), $MachinePrecision], If[Less[y4, -3.364603505246317e-66], N[(N[(N[(N[(N[(N[(t * c), $MachinePrecision] * N[(i * z), $MachinePrecision]), $MachinePrecision] - N[(N[(a * t), $MachinePrecision] * N[(b * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y * c), $MachinePrecision] * N[(i * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$10), $MachinePrecision] + N[(N[(N[(N[(y0 * c), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision] - N[(N[(t$95$17 * N[(N[(y4 * c), $MachinePrecision] - N[(a * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(y1 * y4), $MachinePrecision] - N[(y5 * y0), $MachinePrecision]), $MachinePrecision] * t$95$4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Less[y4, -1.2000065055686116e-105], t$95$16, If[Less[y4, 6.718963124057495e-279], t$95$15, If[Less[y4, 4.77962681403792e-222], t$95$16, If[Less[y4, 2.2852241541266835e-175], t$95$15, N[(N[(N[(N[(N[(N[(N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] * N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(k * N[(i * N[(z * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(j * N[(i * N[(x * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(k * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(y3 * N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * N[(x * N[(a * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(z * N[(c * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision]), $MachinePrecision] - N[(t$95$17 * t$95$1), $MachinePrecision]), $MachinePrecision] + t$95$13), $MachinePrecision]]]]]]]]]]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y4 \cdot c - y5 \cdot a\\
t_2 := x \cdot y2 - z \cdot y3\\
t_3 := y2 \cdot t - y3 \cdot y\\
t_4 := k \cdot y2 - j \cdot y3\\
t_5 := y4 \cdot b - y5 \cdot i\\
t_6 := \left(j \cdot t - k \cdot y\right) \cdot t\_5\\
t_7 := b \cdot a - i \cdot c\\
t_8 := t\_7 \cdot \left(y \cdot x - t \cdot z\right)\\
t_9 := j \cdot x - k \cdot z\\
t_10 := \left(b \cdot y0 - i \cdot y1\right) \cdot t\_9\\
t_11 := t\_9 \cdot \left(y0 \cdot b - i \cdot y1\right)\\
t_12 := y4 \cdot y1 - y5 \cdot y0\\
t_13 := t\_4 \cdot t\_12\\
t_14 := \left(y2 \cdot k - y3 \cdot j\right) \cdot t\_12\\
t_15 := \left(\left(\left(\left(k \cdot y\right) \cdot \left(y5 \cdot i\right) - \left(y \cdot b\right) \cdot \left(y4 \cdot k\right)\right) - \left(y5 \cdot t\right) \cdot \left(i \cdot j\right)\right) - \left(t\_3 \cdot t\_1 - t\_14\right)\right) + \left(t\_8 - \left(t\_11 - \left(y2 \cdot x - y3 \cdot z\right) \cdot \left(c \cdot y0 - y1 \cdot a\right)\right)\right)\\
t_16 := \left(\left(t\_6 - \left(y3 \cdot y\right) \cdot \left(y5 \cdot a - y4 \cdot c\right)\right) + \left(\left(y5 \cdot a\right) \cdot \left(t \cdot y2\right) + t\_13\right)\right) + \left(t\_2 \cdot \left(c \cdot y0 - a \cdot y1\right) - \left(t\_10 - \left(y \cdot x - z \cdot t\right) \cdot t\_7\right)\right)\\
t_17 := t \cdot y2 - y \cdot y3\\
\mathbf{if}\;y4 < -7.206256231996481 \cdot 10^{+60}:\\
\;\;\;\;\left(t\_8 - \left(t\_11 - t\_6\right)\right) - \left(\frac{t\_3}{\frac{1}{t\_1}} - t\_14\right)\\
\mathbf{elif}\;y4 < -3.364603505246317 \cdot 10^{-66}:\\
\;\;\;\;\left(\left(\left(\left(t \cdot c\right) \cdot \left(i \cdot z\right) - \left(a \cdot t\right) \cdot \left(b \cdot z\right)\right) - \left(y \cdot c\right) \cdot \left(i \cdot x\right)\right) - t\_10\right) + \left(\left(y0 \cdot c - a \cdot y1\right) \cdot t\_2 - \left(t\_17 \cdot \left(y4 \cdot c - a \cdot y5\right) - \left(y1 \cdot y4 - y5 \cdot y0\right) \cdot t\_4\right)\right)\\
\mathbf{elif}\;y4 < -1.2000065055686116 \cdot 10^{-105}:\\
\;\;\;\;t\_16\\
\mathbf{elif}\;y4 < 6.718963124057495 \cdot 10^{-279}:\\
\;\;\;\;t\_15\\
\mathbf{elif}\;y4 < 4.77962681403792 \cdot 10^{-222}:\\
\;\;\;\;t\_16\\
\mathbf{elif}\;y4 < 2.2852241541266835 \cdot 10^{-175}:\\
\;\;\;\;t\_15\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(\left(\left(x \cdot y - z \cdot t\right) \cdot \left(a \cdot b - c \cdot i\right) - \left(k \cdot \left(i \cdot \left(z \cdot y1\right)\right) - \left(j \cdot \left(i \cdot \left(x \cdot y1\right)\right) + y0 \cdot \left(k \cdot \left(z \cdot b\right)\right)\right)\right)\right) + \left(z \cdot \left(y3 \cdot \left(a \cdot y1\right)\right) - \left(y2 \cdot \left(x \cdot \left(a \cdot y1\right)\right) + y0 \cdot \left(z \cdot \left(c \cdot y3\right)\right)\right)\right)\right) + \left(t \cdot j - y \cdot k\right) \cdot t\_5\right) - t\_17 \cdot t\_1\right) + t\_13\\
\end{array}
\end{array}
herbie shell --seed 2024235
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:name "Linear.Matrix:det44 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< y4 -7206256231996481000000000000000000000000000000000000000000000) (- (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))))) (- (/ (- (* y2 t) (* y3 y)) (/ 1 (- (* y4 c) (* y5 a)))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (if (< y4 -3364603505246317/1000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* t c) (* i z)) (* (* a t) (* b z))) (* (* y c) (* i x))) (* (- (* b y0) (* i y1)) (- (* j x) (* k z)))) (- (* (- (* y0 c) (* a y1)) (- (* x y2) (* z y3))) (- (* (- (* t y2) (* y y3)) (- (* y4 c) (* a y5))) (* (- (* y1 y4) (* y5 y0)) (- (* k y2) (* j y3)))))) (if (< y4 -3000016263921529/2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (+ (- (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))) (* (* y3 y) (- (* y5 a) (* y4 c)))) (+ (* (* y5 a) (* t y2)) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* x y2) (* z y3)) (- (* c y0) (* a y1))) (- (* (- (* b y0) (* i y1)) (- (* j x) (* k z))) (* (- (* y x) (* z t)) (- (* b a) (* i c)))))) (if (< y4 1343792624811499/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* k y) (* y5 i)) (* (* y b) (* y4 k))) (* (* y5 t) (* i j))) (- (* (- (* y2 t) (* y3 y)) (- (* y4 c) (* y5 a))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))) (if (< y4 29872667587737/6250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (+ (- (* (- (* j t) (* k y)) (- (* y4 b) (* y5 i))) (* (* y3 y) (- (* y5 a) (* y4 c)))) (+ (* (* y5 a) (* t y2)) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* x y2) (* z y3)) (- (* c y0) (* a y1))) (- (* (- (* b y0) (* i y1)) (- (* j x) (* k z))) (* (- (* y x) (* z t)) (- (* b a) (* i c)))))) (if (< y4 4570448308253367/20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (- (- (* (* k y) (* y5 i)) (* (* y b) (* y4 k))) (* (* y5 t) (* i j))) (- (* (- (* y2 t) (* y3 y)) (- (* y4 c) (* y5 a))) (* (- (* y2 k) (* y3 j)) (- (* y4 y1) (* y5 y0))))) (- (* (- (* b a) (* i c)) (- (* y x) (* t z))) (- (* (- (* j x) (* k z)) (- (* y0 b) (* i y1))) (* (- (* y2 x) (* y3 z)) (- (* c y0) (* y1 a)))))) (+ (- (+ (+ (- (* (- (* x y) (* z t)) (- (* a b) (* c i))) (- (* k (* i (* z y1))) (+ (* j (* i (* x y1))) (* y0 (* k (* z b)))))) (- (* z (* y3 (* a y1))) (+ (* y2 (* x (* a y1))) (* y0 (* z (* c y3)))))) (* (- (* t j) (* y k)) (- (* y4 b) (* y5 i)))) (* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a)))) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))))))))
(+ (- (+ (+ (- (* (- (* x y) (* z t)) (- (* a b) (* c i))) (* (- (* x j) (* z k)) (- (* y0 b) (* y1 i)))) (* (- (* x y2) (* z y3)) (- (* y0 c) (* y1 a)))) (* (- (* t j) (* y k)) (- (* y4 b) (* y5 i)))) (* (- (* t y2) (* y y3)) (- (* y4 c) (* y5 a)))) (* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0)))))