
(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 35 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 y2 k (* (- j) y3)))
(t_2 (fma y4 c (* (- a) y5)))
(t_3
(*
(-
(fma (- z) (fma b a (* (- c) i)) (* (fma y4 b (* (- i) y5)) j))
(* t_2 y2))
t)))
(if (<= t -2.1e+83)
t_3
(if (<= t -4.8e-189)
(*
(-
(fma (- y5) t_1 (* (fma y2 x (* (- y3) z)) c))
(* (fma j x (* (- k) z)) b))
y0)
(if (<= t -5.5e-296)
(*
(- y5)
(-
(fma t_1 y0 (* (fma j t (* (- k) y)) i))
(* (fma y2 t (* (- y) y3)) a)))
(if (<= t 4.8e-110)
(+
(* (- k) (fma -1.0 (* (* b y0) z) (* b (* y y4))))
(* (- (* k y2) (* j y3)) (- (* y4 y1) (* y5 y0))))
(if (<= t 3.65e+168)
(*
(-
(fma (fma y4 y1 (* (- y0) y5)) k (* (fma y0 c (* (- a) y1)) x))
(* t_2 t))
y2)
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 = fma(y2, k, (-j * y3));
double t_2 = fma(y4, c, (-a * y5));
double t_3 = (fma(-z, fma(b, a, (-c * i)), (fma(y4, b, (-i * y5)) * j)) - (t_2 * y2)) * t;
double tmp;
if (t <= -2.1e+83) {
tmp = t_3;
} else if (t <= -4.8e-189) {
tmp = (fma(-y5, t_1, (fma(y2, x, (-y3 * z)) * c)) - (fma(j, x, (-k * z)) * b)) * y0;
} else if (t <= -5.5e-296) {
tmp = -y5 * (fma(t_1, y0, (fma(j, t, (-k * y)) * i)) - (fma(y2, t, (-y * y3)) * a));
} else if (t <= 4.8e-110) {
tmp = (-k * fma(-1.0, ((b * y0) * z), (b * (y * y4)))) + (((k * y2) - (j * y3)) * ((y4 * y1) - (y5 * y0)));
} else if (t <= 3.65e+168) {
tmp = (fma(fma(y4, y1, (-y0 * y5)), k, (fma(y0, c, (-a * y1)) * x)) - (t_2 * t)) * y2;
} 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 = fma(y2, k, Float64(Float64(-j) * y3)) t_2 = fma(y4, c, Float64(Float64(-a) * y5)) t_3 = Float64(Float64(fma(Float64(-z), fma(b, a, Float64(Float64(-c) * i)), Float64(fma(y4, b, Float64(Float64(-i) * y5)) * j)) - Float64(t_2 * y2)) * t) tmp = 0.0 if (t <= -2.1e+83) tmp = t_3; elseif (t <= -4.8e-189) tmp = Float64(Float64(fma(Float64(-y5), t_1, Float64(fma(y2, x, Float64(Float64(-y3) * z)) * c)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); elseif (t <= -5.5e-296) tmp = Float64(Float64(-y5) * Float64(fma(t_1, y0, Float64(fma(j, t, Float64(Float64(-k) * y)) * i)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * a))); elseif (t <= 4.8e-110) tmp = Float64(Float64(Float64(-k) * fma(-1.0, Float64(Float64(b * y0) * z), Float64(b * Float64(y * y4)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y4 * y1) - Float64(y5 * y0)))); elseif (t <= 3.65e+168) tmp = Float64(Float64(fma(fma(y4, y1, Float64(Float64(-y0) * y5)), k, Float64(fma(y0, c, Float64(Float64(-a) * y1)) * x)) - Float64(t_2 * t)) * y2); 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[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[((-z) * N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] + N[(N[(y4 * b + N[((-i) * y5), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] - N[(t$95$2 * y2), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t, -2.1e+83], t$95$3, If[LessEqual[t, -4.8e-189], N[(N[(N[((-y5) * t$95$1 + N[(N[(y2 * x + N[((-y3) * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[t, -5.5e-296], N[((-y5) * N[(N[(t$95$1 * y0 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.8e-110], N[(N[((-k) * N[(-1.0 * N[(N[(b * y0), $MachinePrecision] * z), $MachinePrecision] + N[(b * N[(y * y4), $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], If[LessEqual[t, 3.65e+168], N[(N[(N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * k + N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - N[(t$95$2 * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], t$95$3]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right)\\
t_2 := \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right)\\
t_3 := \left(\mathsf{fma}\left(-z, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right), \mathsf{fma}\left(y4, b, \left(-i\right) \cdot y5\right) \cdot j\right) - t\_2 \cdot y2\right) \cdot t\\
\mathbf{if}\;t \leq -2.1 \cdot 10^{+83}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t \leq -4.8 \cdot 10^{-189}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y5, t\_1, \mathsf{fma}\left(y2, x, \left(-y3\right) \cdot z\right) \cdot c\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{elif}\;t \leq -5.5 \cdot 10^{-296}:\\
\;\;\;\;\left(-y5\right) \cdot \left(\mathsf{fma}\left(t\_1, y0, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot i\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot a\right)\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{-110}:\\
\;\;\;\;\left(-k\right) \cdot \mathsf{fma}\left(-1, \left(b \cdot y0\right) \cdot z, b \cdot \left(y \cdot y4\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y4 \cdot y1 - y5 \cdot y0\right)\\
\mathbf{elif}\;t \leq 3.65 \cdot 10^{+168}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), k, \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right) \cdot x\right) - t\_2 \cdot t\right) \cdot y2\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if t < -2.10000000000000002e83 or 3.6499999999999998e168 < t Initial program 19.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.5%
if -2.10000000000000002e83 < t < -4.7999999999999997e-189Initial program 37.3%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.1%
if -4.7999999999999997e-189 < t < -5.5000000000000004e-296Initial program 32.3%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites64.3%
if -5.5000000000000004e-296 < t < 4.80000000000000013e-110Initial program 29.4%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites44.8%
Taylor expanded in i around 0
Applied rewrites66.0%
if 4.80000000000000013e-110 < t < 3.6499999999999998e168Initial program 39.2%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.5%
Final simplification61.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(+
(-
(+
(+
(-
(* (- (* 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))))))
(if (<= t_1 INFINITY)
t_1
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) 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 = (((((((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 tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
}
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(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)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * 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[(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]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \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)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\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 88.5%
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
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites33.0%
Taylor expanded in y0 around inf
Applied rewrites43.6%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites46.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y4 c (* (- a) y5)))
(t_2
(*
(-
(fma (- z) (fma b a (* (- c) i)) (* (fma y4 b (* (- i) y5)) j))
(* t_1 y2))
t))
(t_3 (fma y4 y1 (* (- y0) y5))))
(if (<= t -2.1e+83)
t_2
(if (<= t -1.75e-266)
(*
(-
(fma (- y5) (fma y2 k (* (- j) y3)) (* (fma y2 x (* (- y3) z)) c))
(* (fma j x (* (- k) z)) b))
y0)
(if (<= t 2.6e-278)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(if (<= t 4.5e+47)
(fma t_3 (fma y2 k (* (- y3) j)) (* z (* y0 (* b k))))
(if (<= t 3.65e+168)
(* (- (fma t_3 k (* (fma y0 c (* (- a) y1)) x)) (* t_1 t)) y2)
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 = fma(y4, c, (-a * y5));
double t_2 = (fma(-z, fma(b, a, (-c * i)), (fma(y4, b, (-i * y5)) * j)) - (t_1 * y2)) * t;
double t_3 = fma(y4, y1, (-y0 * y5));
double tmp;
if (t <= -2.1e+83) {
tmp = t_2;
} else if (t <= -1.75e-266) {
tmp = (fma(-y5, fma(y2, k, (-j * y3)), (fma(y2, x, (-y3 * z)) * c)) - (fma(j, x, (-k * z)) * b)) * y0;
} else if (t <= 2.6e-278) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else if (t <= 4.5e+47) {
tmp = fma(t_3, fma(y2, k, (-y3 * j)), (z * (y0 * (b * k))));
} else if (t <= 3.65e+168) {
tmp = (fma(t_3, k, (fma(y0, c, (-a * y1)) * x)) - (t_1 * t)) * y2;
} 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 = fma(y4, c, Float64(Float64(-a) * y5)) t_2 = Float64(Float64(fma(Float64(-z), fma(b, a, Float64(Float64(-c) * i)), Float64(fma(y4, b, Float64(Float64(-i) * y5)) * j)) - Float64(t_1 * y2)) * t) t_3 = fma(y4, y1, Float64(Float64(-y0) * y5)) tmp = 0.0 if (t <= -2.1e+83) tmp = t_2; elseif (t <= -1.75e-266) tmp = Float64(Float64(fma(Float64(-y5), fma(y2, k, Float64(Float64(-j) * y3)), Float64(fma(y2, x, Float64(Float64(-y3) * z)) * c)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); elseif (t <= 2.6e-278) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); elseif (t <= 4.5e+47) tmp = fma(t_3, fma(y2, k, Float64(Float64(-y3) * j)), Float64(z * Float64(y0 * Float64(b * k)))); elseif (t <= 3.65e+168) tmp = Float64(Float64(fma(t_3, k, Float64(fma(y0, c, Float64(Float64(-a) * y1)) * x)) - Float64(t_1 * t)) * y2); 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[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[((-z) * N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] + N[(N[(y4 * b + N[((-i) * y5), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * y2), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, Block[{t$95$3 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.1e+83], t$95$2, If[LessEqual[t, -1.75e-266], N[(N[(N[((-y5) * N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] + N[(N[(y2 * x + N[((-y3) * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[t, 2.6e-278], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[t, 4.5e+47], N[(t$95$3 * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(z * N[(y0 * N[(b * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.65e+168], N[(N[(N[(t$95$3 * k + N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right)\\
t_2 := \left(\mathsf{fma}\left(-z, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right), \mathsf{fma}\left(y4, b, \left(-i\right) \cdot y5\right) \cdot j\right) - t\_1 \cdot y2\right) \cdot t\\
t_3 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
\mathbf{if}\;t \leq -2.1 \cdot 10^{+83}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -1.75 \cdot 10^{-266}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y5, \mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), \mathsf{fma}\left(y2, x, \left(-y3\right) \cdot z\right) \cdot c\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{elif}\;t \leq 2.6 \cdot 10^{-278}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{+47}:\\
\;\;\;\;\mathsf{fma}\left(t\_3, \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), z \cdot \left(y0 \cdot \left(b \cdot k\right)\right)\right)\\
\mathbf{elif}\;t \leq 3.65 \cdot 10^{+168}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_3, k, \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right) \cdot x\right) - t\_1 \cdot t\right) \cdot y2\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -2.10000000000000002e83 or 3.6499999999999998e168 < t Initial program 19.3%
Taylor expanded in t around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.5%
if -2.10000000000000002e83 < t < -1.75000000000000015e-266Initial program 37.5%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.3%
if -1.75000000000000015e-266 < t < 2.5999999999999999e-278Initial program 23.8%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.8%
Taylor expanded in y1 around -inf
Applied rewrites69.9%
if 2.5999999999999999e-278 < t < 4.49999999999999979e47Initial program 32.7%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites39.9%
Taylor expanded in y0 around inf
Applied rewrites50.1%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites53.0%
Applied rewrites54.3%
if 4.49999999999999979e47 < t < 3.6499999999999998e168Initial program 44.8%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites70.7%
Final simplification61.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y2 k (* (- j) y3)))
(t_2
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)))
(if (<= y0 -1.15e+54)
(*
(-
(fma (- y5) t_1 (* (fma y2 x (* (- y3) z)) c))
(* (fma j x (* (- k) z)) b))
y0)
(if (<= y0 -2e-75)
t_2
(if (<= y0 8.5e-102)
(*
(-
(fma t_1 y1 (* (fma j t (* (- k) y)) b))
(* (fma y2 t (* (- y) y3)) c))
y4)
(if (<= y0 3e+84)
t_2
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) 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(y2, k, (-j * y3));
double t_2 = (fma(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double tmp;
if (y0 <= -1.15e+54) {
tmp = (fma(-y5, t_1, (fma(y2, x, (-y3 * z)) * c)) - (fma(j, x, (-k * z)) * b)) * y0;
} else if (y0 <= -2e-75) {
tmp = t_2;
} else if (y0 <= 8.5e-102) {
tmp = (fma(t_1, y1, (fma(j, t, (-k * y)) * b)) - (fma(y2, t, (-y * y3)) * c)) * y4;
} else if (y0 <= 3e+84) {
tmp = t_2;
} else {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(y2, k, Float64(Float64(-j) * y3)) t_2 = Float64(Float64(fma(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) tmp = 0.0 if (y0 <= -1.15e+54) tmp = Float64(Float64(fma(Float64(-y5), t_1, Float64(fma(y2, x, Float64(Float64(-y3) * z)) * c)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * b)) * y0); elseif (y0 <= -2e-75) tmp = t_2; elseif (y0 <= 8.5e-102) tmp = Float64(Float64(fma(t_1, y1, Float64(fma(j, t, Float64(Float64(-k) * y)) * b)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * c)) * y4); elseif (y0 <= 3e+84) tmp = t_2; else tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * 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[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[y0, -1.15e+54], N[(N[(N[((-y5) * t$95$1 + N[(N[(y2 * x + N[((-y3) * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision], If[LessEqual[y0, -2e-75], t$95$2, If[LessEqual[y0, 8.5e-102], N[(N[(N[(t$95$1 * y1 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], If[LessEqual[y0, 3e+84], t$95$2, N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right)\\
t_2 := \left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{if}\;y0 \leq -1.15 \cdot 10^{+54}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y5, t\_1, \mathsf{fma}\left(y2, x, \left(-y3\right) \cdot z\right) \cdot c\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot b\right) \cdot y0\\
\mathbf{elif}\;y0 \leq -2 \cdot 10^{-75}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y0 \leq 8.5 \cdot 10^{-102}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_1, y1, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot b\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot c\right) \cdot y4\\
\mathbf{elif}\;y0 \leq 3 \cdot 10^{+84}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\end{array}
\end{array}
if y0 < -1.14999999999999997e54Initial program 26.1%
Taylor expanded in y0 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites74.6%
if -1.14999999999999997e54 < y0 < -1.9999999999999999e-75 or 8.49999999999999973e-102 < y0 < 2.99999999999999996e84Initial program 34.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites56.8%
if -1.9999999999999999e-75 < y0 < 8.49999999999999973e-102Initial program 35.8%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.5%
if 2.99999999999999996e84 < y0 Initial program 24.4%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites51.6%
Taylor expanded in y0 around inf
Applied rewrites59.2%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites64.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)))
(if (<= x -1.56e+208)
t_1
(if (<= x 1.4e-137)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b))
(if (<= x 3.35e-69)
(*
(- y5)
(-
(fma (fma y2 k (* (- j) y3)) y0 (* (fma j t (* (- k) y)) i))
(* (fma y2 t (* (- y) y3)) a)))
(if (<= x 2.7e+34)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) 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(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double tmp;
if (x <= -1.56e+208) {
tmp = t_1;
} else if (x <= 1.4e-137) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 3.35e-69) {
tmp = -y5 * (fma(fma(y2, k, (-j * y3)), y0, (fma(j, t, (-k * y)) * i)) - (fma(y2, t, (-y * y3)) * a));
} else if (x <= 2.7e+34) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * 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(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) tmp = 0.0 if (x <= -1.56e+208) tmp = t_1; elseif (x <= 1.4e-137) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 3.35e-69) tmp = Float64(Float64(-y5) * Float64(fma(fma(y2, k, Float64(Float64(-j) * y3)), y0, Float64(fma(j, t, Float64(Float64(-k) * y)) * i)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * a))); elseif (x <= 2.7e+34) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * 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[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$1, If[LessEqual[x, 1.4e-137], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.35e-69], N[((-y5) * N[(N[(N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y0 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7e+34], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.4 \cdot 10^{-137}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 3.35 \cdot 10^{-69}:\\
\;\;\;\;\left(-y5\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), y0, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot i\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot a\right)\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{+34}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 2.7e34 < x Initial program 27.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.1%
if -1.55999999999999989e208 < x < 1.3999999999999999e-137Initial program 32.8%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.4%
Taylor expanded in y0 around inf
Applied rewrites52.2%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites55.0%
if 1.3999999999999999e-137 < x < 3.35e-69Initial program 30.6%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites77.7%
if 3.35e-69 < x < 2.7e34Initial program 36.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites37.9%
Taylor expanded in t around inf
Applied rewrites53.8%
Taylor expanded in y4 around -inf
Applied rewrites63.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y0 c (* (- a) y1)))
(t_2
(*
(-
(fma t_1 y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x))
(t_3 (fma y4 y1 (* (- y0) y5))))
(if (<= x -1.56e+208)
t_2
(if (<= x 7.2e-177)
(fma t_3 (fma y2 k (* (- y3) j)) (* (* (* y0 z) k) b))
(if (<= x 7.8e-57)
(* (- y3) (- (fma t_3 j (* t_1 z)) (* (fma y4 c (* (- a) y5)) y)))
(if (<= x 4.2e+209)
(*
(-
(fma (fma y2 k (* (- j) y3)) y1 (* (fma j t (* (- k) y)) b))
(* (fma y2 t (* (- y) y3)) c))
y4)
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 = fma(y0, c, (-a * y1));
double t_2 = (fma(t_1, y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double t_3 = fma(y4, y1, (-y0 * y5));
double tmp;
if (x <= -1.56e+208) {
tmp = t_2;
} else if (x <= 7.2e-177) {
tmp = fma(t_3, fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 7.8e-57) {
tmp = -y3 * (fma(t_3, j, (t_1 * z)) - (fma(y4, c, (-a * y5)) * y));
} else if (x <= 4.2e+209) {
tmp = (fma(fma(y2, k, (-j * y3)), y1, (fma(j, t, (-k * y)) * b)) - (fma(y2, t, (-y * y3)) * c)) * y4;
} 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 = fma(y0, c, Float64(Float64(-a) * y1)) t_2 = Float64(Float64(fma(t_1, y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) t_3 = fma(y4, y1, Float64(Float64(-y0) * y5)) tmp = 0.0 if (x <= -1.56e+208) tmp = t_2; elseif (x <= 7.2e-177) tmp = fma(t_3, fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 7.8e-57) tmp = Float64(Float64(-y3) * Float64(fma(t_3, j, Float64(t_1 * z)) - Float64(fma(y4, c, Float64(Float64(-a) * y5)) * y))); elseif (x <= 4.2e+209) tmp = Float64(Float64(fma(fma(y2, k, Float64(Float64(-j) * y3)), y1, Float64(fma(j, t, Float64(Float64(-k) * y)) * b)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * c)) * y4); 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[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(t$95$1 * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$3 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$2, If[LessEqual[x, 7.2e-177], N[(t$95$3 * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7.8e-57], N[((-y3) * N[(N[(t$95$3 * j + N[(t$95$1 * z), $MachinePrecision]), $MachinePrecision] - N[(N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e+209], N[(N[(N[(N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right)\\
t_2 := \left(\mathsf{fma}\left(t\_1, y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
t_3 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 7.2 \cdot 10^{-177}:\\
\;\;\;\;\mathsf{fma}\left(t\_3, \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 7.8 \cdot 10^{-57}:\\
\;\;\;\;\left(-y3\right) \cdot \left(\mathsf{fma}\left(t\_3, j, t\_1 \cdot z\right) - \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right) \cdot y\right)\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{+209}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), y1, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot b\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot c\right) \cdot y4\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 4.2e209 < x Initial program 26.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites76.2%
if -1.55999999999999989e208 < x < 7.19999999999999965e-177Initial program 33.3%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.5%
Taylor expanded in y0 around inf
Applied rewrites53.1%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites56.2%
if 7.19999999999999965e-177 < x < 7.80000000000000013e-57Initial program 26.6%
Taylor expanded in y3 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.4%
if 7.80000000000000013e-57 < x < 4.2e209Initial program 34.0%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x))
(t_2 (fma j t (* (- k) y))))
(if (<= x -1.56e+208)
t_1
(if (<= x 2.5e-124)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b))
(if (<= x 2.8e-36)
(*
(- i)
(-
(fma (fma y x (* (- t) z)) c (* t_2 y5))
(* (fma j x (* (- k) z)) y1)))
(if (<= x 4.2e+209)
(*
(-
(fma (fma y2 k (* (- j) y3)) y1 (* t_2 b))
(* (fma y2 t (* (- y) y3)) c))
y4)
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(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double t_2 = fma(j, t, (-k * y));
double tmp;
if (x <= -1.56e+208) {
tmp = t_1;
} else if (x <= 2.5e-124) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 2.8e-36) {
tmp = -i * (fma(fma(y, x, (-t * z)), c, (t_2 * y5)) - (fma(j, x, (-k * z)) * y1));
} else if (x <= 4.2e+209) {
tmp = (fma(fma(y2, k, (-j * y3)), y1, (t_2 * b)) - (fma(y2, t, (-y * y3)) * c)) * y4;
} 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(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) t_2 = fma(j, t, Float64(Float64(-k) * y)) tmp = 0.0 if (x <= -1.56e+208) tmp = t_1; elseif (x <= 2.5e-124) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 2.8e-36) tmp = Float64(Float64(-i) * Float64(fma(fma(y, x, Float64(Float64(-t) * z)), c, Float64(t_2 * y5)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * y1))); elseif (x <= 4.2e+209) tmp = Float64(Float64(fma(fma(y2, k, Float64(Float64(-j) * y3)), y1, Float64(t_2 * b)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * c)) * y4); 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[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$2 = N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$1, If[LessEqual[x, 2.5e-124], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.8e-36], N[((-i) * N[(N[(N[(y * x + N[((-t) * z), $MachinePrecision]), $MachinePrecision] * c + N[(t$95$2 * y5), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e+209], N[(N[(N[(N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y1 + N[(t$95$2 * b), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
t_2 := \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right)\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.5 \cdot 10^{-124}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 2.8 \cdot 10^{-36}:\\
\;\;\;\;\left(-i\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y, x, \left(-t\right) \cdot z\right), c, t\_2 \cdot y5\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot y1\right)\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{+209}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), y1, t\_2 \cdot b\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot c\right) \cdot y4\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 4.2e209 < x Initial program 26.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites76.2%
if -1.55999999999999989e208 < x < 2.5000000000000001e-124Initial program 32.6%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.1%
Taylor expanded in y0 around inf
Applied rewrites51.9%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites54.6%
if 2.5000000000000001e-124 < x < 2.8000000000000001e-36Initial program 31.5%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.1%
if 2.8000000000000001e-36 < x < 4.2e209Initial program 32.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y0 c (* (- a) y1)))
(t_2
(*
(-
(fma t_1 y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x))
(t_3 (fma y4 y1 (* (- y0) y5))))
(if (<= x -1.56e+208)
t_2
(if (<= x 2.7e-165)
(fma t_3 (fma y2 k (* (- y3) j)) (* (* (* y0 z) k) b))
(if (<= x 3.35e-69)
(* (- (fma t_3 k (* t_1 x)) (* (fma y4 c (* (- a) y5)) t)) y2)
(if (<= x 2.7e+34)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) b)
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 = fma(y0, c, (-a * y1));
double t_2 = (fma(t_1, y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double t_3 = fma(y4, y1, (-y0 * y5));
double tmp;
if (x <= -1.56e+208) {
tmp = t_2;
} else if (x <= 2.7e-165) {
tmp = fma(t_3, fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 3.35e-69) {
tmp = (fma(t_3, k, (t_1 * x)) - (fma(y4, c, (-a * y5)) * t)) * y2;
} else if (x <= 2.7e+34) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * b;
} 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 = fma(y0, c, Float64(Float64(-a) * y1)) t_2 = Float64(Float64(fma(t_1, y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) t_3 = fma(y4, y1, Float64(Float64(-y0) * y5)) tmp = 0.0 if (x <= -1.56e+208) tmp = t_2; elseif (x <= 2.7e-165) tmp = fma(t_3, fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 3.35e-69) tmp = Float64(Float64(fma(t_3, k, Float64(t_1 * x)) - Float64(fma(y4, c, Float64(Float64(-a) * y5)) * t)) * y2); elseif (x <= 2.7e+34) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * b); 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[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(t$95$1 * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, Block[{t$95$3 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$2, If[LessEqual[x, 2.7e-165], N[(t$95$3 * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.35e-69], N[(N[(N[(t$95$3 * k + N[(t$95$1 * x), $MachinePrecision]), $MachinePrecision] - N[(N[(y4 * c + N[((-a) * y5), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] * y2), $MachinePrecision], If[LessEqual[x, 2.7e+34], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right)\\
t_2 := \left(\mathsf{fma}\left(t\_1, y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
t_3 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{-165}:\\
\;\;\;\;\mathsf{fma}\left(t\_3, \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 3.35 \cdot 10^{-69}:\\
\;\;\;\;\left(\mathsf{fma}\left(t\_3, k, t\_1 \cdot x\right) - \mathsf{fma}\left(y4, c, \left(-a\right) \cdot y5\right) \cdot t\right) \cdot y2\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{+34}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 2.7e34 < x Initial program 27.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.1%
if -1.55999999999999989e208 < x < 2.6999999999999998e-165Initial program 33.3%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.3%
Taylor expanded in y0 around inf
Applied rewrites53.4%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites56.4%
if 2.6999999999999998e-165 < x < 3.35e-69Initial program 29.1%
Taylor expanded in y2 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites50.4%
if 3.35e-69 < x < 2.7e34Initial program 36.8%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites37.9%
Taylor expanded in t around inf
Applied rewrites53.8%
Taylor expanded in y4 around -inf
Applied rewrites63.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (fma y0 b (* (- i) y1))) (t_2 (fma y4 y1 (* (- y0) y5))))
(if (<= x -1.56e+208)
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* t_1 j))
x)
(if (<= x 1.4e-137)
(fma t_2 (fma y2 k (* (- y3) j)) (* (* (* y0 z) k) b))
(if (<= x 1.6e+32)
(*
(- y5)
(-
(fma (fma y2 k (* (- j) y3)) y0 (* (fma j t (* (- k) y)) i))
(* (fma y2 t (* (- y) y3)) a)))
(*
(- (fma (- y3) t_2 (* (fma y4 b (* (- i) y5)) t)) (* t_1 x))
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) {
double t_1 = fma(y0, b, (-i * y1));
double t_2 = fma(y4, y1, (-y0 * y5));
double tmp;
if (x <= -1.56e+208) {
tmp = (fma(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (t_1 * j)) * x;
} else if (x <= 1.4e-137) {
tmp = fma(t_2, fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 1.6e+32) {
tmp = -y5 * (fma(fma(y2, k, (-j * y3)), y0, (fma(j, t, (-k * y)) * i)) - (fma(y2, t, (-y * y3)) * a));
} else {
tmp = (fma(-y3, t_2, (fma(y4, b, (-i * y5)) * t)) - (t_1 * x)) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(y0, b, Float64(Float64(-i) * y1)) t_2 = fma(y4, y1, Float64(Float64(-y0) * y5)) tmp = 0.0 if (x <= -1.56e+208) tmp = Float64(Float64(fma(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(t_1 * j)) * x); elseif (x <= 1.4e-137) tmp = fma(t_2, fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 1.6e+32) tmp = Float64(Float64(-y5) * Float64(fma(fma(y2, k, Float64(Float64(-j) * y3)), y0, Float64(fma(j, t, Float64(Float64(-k) * y)) * i)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * a))); else tmp = Float64(Float64(fma(Float64(-y3), t_2, Float64(fma(y4, b, Float64(Float64(-i) * y5)) * t)) - Float64(t_1 * x)) * j); 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[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], N[(N[(N[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], If[LessEqual[x, 1.4e-137], N[(t$95$2 * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.6e+32], N[((-y5) * N[(N[(N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y0 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * i), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[((-y3) * t$95$2 + N[(N[(y4 * b + N[((-i) * y5), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] - N[(t$95$1 * x), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right)\\
t_2 := \mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right)\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - t\_1 \cdot j\right) \cdot x\\
\mathbf{elif}\;x \leq 1.4 \cdot 10^{-137}:\\
\;\;\;\;\mathsf{fma}\left(t\_2, \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 1.6 \cdot 10^{+32}:\\
\;\;\;\;\left(-y5\right) \cdot \left(\mathsf{fma}\left(\mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), y0, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot i\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(-y3, t\_2, \mathsf{fma}\left(y4, b, \left(-i\right) \cdot y5\right) \cdot t\right) - t\_1 \cdot x\right) \cdot j\\
\end{array}
\end{array}
if x < -1.55999999999999989e208Initial program 34.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites80.0%
if -1.55999999999999989e208 < x < 1.3999999999999999e-137Initial program 32.8%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.4%
Taylor expanded in y0 around inf
Applied rewrites52.2%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites55.0%
if 1.3999999999999999e-137 < x < 1.5999999999999999e32Initial program 32.2%
Taylor expanded in y5 around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites55.6%
if 1.5999999999999999e32 < x Initial program 26.8%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)))
(if (<= x -1.56e+208)
t_1
(if (<= x 4e-172)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b))
(if (<= x 4.2e+209)
(*
(-
(fma (fma y2 k (* (- j) y3)) y1 (* (fma j t (* (- k) y)) b))
(* (fma y2 t (* (- y) y3)) c))
y4)
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(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double tmp;
if (x <= -1.56e+208) {
tmp = t_1;
} else if (x <= 4e-172) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 4.2e+209) {
tmp = (fma(fma(y2, k, (-j * y3)), y1, (fma(j, t, (-k * y)) * b)) - (fma(y2, t, (-y * y3)) * c)) * y4;
} 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(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) tmp = 0.0 if (x <= -1.56e+208) tmp = t_1; elseif (x <= 4e-172) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 4.2e+209) tmp = Float64(Float64(fma(fma(y2, k, Float64(Float64(-j) * y3)), y1, Float64(fma(j, t, Float64(Float64(-k) * y)) * b)) - Float64(fma(y2, t, Float64(Float64(-y) * y3)) * c)) * y4); 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[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$1, If[LessEqual[x, 4e-172], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.2e+209], N[(N[(N[(N[(y2 * k + N[((-j) * y3), $MachinePrecision]), $MachinePrecision] * y1 + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] - N[(N[(y2 * t + N[((-y) * y3), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4 \cdot 10^{-172}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 4.2 \cdot 10^{+209}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y2, k, \left(-j\right) \cdot y3\right), y1, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot b\right) - \mathsf{fma}\left(y2, t, \left(-y\right) \cdot y3\right) \cdot c\right) \cdot y4\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 4.2e209 < x Initial program 26.1%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites76.2%
if -1.55999999999999989e208 < x < 4.0000000000000002e-172Initial program 33.0%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.2%
Taylor expanded in y0 around inf
Applied rewrites52.7%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites55.8%
if 4.0000000000000002e-172 < x < 4.2e209Initial program 31.7%
Taylor expanded in y4 around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
(-
(fma (fma y0 c (* (- a) y1)) y2 (* (fma b a (* (- c) i)) y))
(* (fma y0 b (* (- i) y1)) j))
x)))
(if (<= x -1.56e+208)
t_1
(if (<= x 5.8e-104)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b))
(if (<= x 2.7e+34)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) 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(fma(y0, c, (-a * y1)), y2, (fma(b, a, (-c * i)) * y)) - (fma(y0, b, (-i * y1)) * j)) * x;
double tmp;
if (x <= -1.56e+208) {
tmp = t_1;
} else if (x <= 5.8e-104) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else if (x <= 2.7e+34) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * 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(fma(y0, c, Float64(Float64(-a) * y1)), y2, Float64(fma(b, a, Float64(Float64(-c) * i)) * y)) - Float64(fma(y0, b, Float64(Float64(-i) * y1)) * j)) * x) tmp = 0.0 if (x <= -1.56e+208) tmp = t_1; elseif (x <= 5.8e-104) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); elseif (x <= 2.7e+34) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * 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[(N[(y0 * c + N[((-a) * y1), $MachinePrecision]), $MachinePrecision] * y2 + N[(N[(b * a + N[((-c) * i), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision] - N[(N[(y0 * b + N[((-i) * y1), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]}, If[LessEqual[x, -1.56e+208], t$95$1, If[LessEqual[x, 5.8e-104], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7e+34], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\mathsf{fma}\left(\mathsf{fma}\left(y0, c, \left(-a\right) \cdot y1\right), y2, \mathsf{fma}\left(b, a, \left(-c\right) \cdot i\right) \cdot y\right) - \mathsf{fma}\left(y0, b, \left(-i\right) \cdot y1\right) \cdot j\right) \cdot x\\
\mathbf{if}\;x \leq -1.56 \cdot 10^{+208}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 5.8 \cdot 10^{-104}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{+34}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.55999999999999989e208 or 2.7e34 < x Initial program 27.9%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.1%
if -1.55999999999999989e208 < x < 5.8000000000000002e-104Initial program 33.5%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites43.1%
Taylor expanded in y0 around inf
Applied rewrites50.2%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites52.9%
if 5.8000000000000002e-104 < x < 2.7e34Initial program 30.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites35.6%
Taylor expanded in t around inf
Applied rewrites43.6%
Taylor expanded in y4 around -inf
Applied rewrites54.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b)))
(t_2 (* (- t) z)))
(if (<= b -3.8e-216)
t_1
(if (<= b 2.4e-114)
(* (fma y0 (fma x y2 (* (- y3) z)) (* (- i) (fma x y t_2))) c)
(if (<= b 4.8e+76)
t_1
(*
(-
(fma (fma y x t_2) a (* (fma j t (* (- k) y)) y4))
(* (fma j x (* (- k) z)) y0))
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(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
double t_2 = -t * z;
double tmp;
if (b <= -3.8e-216) {
tmp = t_1;
} else if (b <= 2.4e-114) {
tmp = fma(y0, fma(x, y2, (-y3 * z)), (-i * fma(x, y, t_2))) * c;
} else if (b <= 4.8e+76) {
tmp = t_1;
} else {
tmp = (fma(fma(y, x, t_2), a, (fma(j, t, (-k * y)) * y4)) - (fma(j, x, (-k * z)) * y0)) * b;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)) t_2 = Float64(Float64(-t) * z) tmp = 0.0 if (b <= -3.8e-216) tmp = t_1; elseif (b <= 2.4e-114) tmp = Float64(fma(y0, fma(x, y2, Float64(Float64(-y3) * z)), Float64(Float64(-i) * fma(x, y, t_2))) * c); elseif (b <= 4.8e+76) tmp = t_1; else tmp = Float64(Float64(fma(fma(y, x, t_2), a, Float64(fma(j, t, Float64(Float64(-k) * y)) * y4)) - Float64(fma(j, x, Float64(Float64(-k) * z)) * y0)) * 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[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-t) * z), $MachinePrecision]}, If[LessEqual[b, -3.8e-216], t$95$1, If[LessEqual[b, 2.4e-114], N[(N[(y0 * N[(x * y2 + N[((-y3) * z), $MachinePrecision]), $MachinePrecision] + N[((-i) * N[(x * y + t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 4.8e+76], t$95$1, N[(N[(N[(N[(y * x + t$95$2), $MachinePrecision] * a + N[(N[(j * t + N[((-k) * y), $MachinePrecision]), $MachinePrecision] * y4), $MachinePrecision]), $MachinePrecision] - N[(N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision] * y0), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
t_2 := \left(-t\right) \cdot z\\
\mathbf{if}\;b \leq -3.8 \cdot 10^{-216}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2.4 \cdot 10^{-114}:\\
\;\;\;\;\mathsf{fma}\left(y0, \mathsf{fma}\left(x, y2, \left(-y3\right) \cdot z\right), \left(-i\right) \cdot \mathsf{fma}\left(x, y, t\_2\right)\right) \cdot c\\
\mathbf{elif}\;b \leq 4.8 \cdot 10^{+76}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(\mathsf{fma}\left(y, x, t\_2\right), a, \mathsf{fma}\left(j, t, \left(-k\right) \cdot y\right) \cdot y4\right) - \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right) \cdot y0\right) \cdot b\\
\end{array}
\end{array}
if b < -3.8e-216 or 2.4000000000000001e-114 < b < 4.8e76Initial program 33.1%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites44.4%
Taylor expanded in y0 around inf
Applied rewrites50.0%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites52.6%
if -3.8e-216 < b < 2.4000000000000001e-114Initial program 35.8%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.2%
Taylor expanded in t around inf
Applied rewrites30.5%
Taylor expanded in y4 around 0
Applied rewrites46.7%
if 4.8e76 < b Initial program 20.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.0%
Final simplification54.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= c -4.9e+25)
(* (* c y2) (fma x y0 (* (- t) y4)))
(if (<= c -2.45e-132)
(* (* (- y0) (fma j x (* (- k) z))) b)
(if (<= c 6.5e-281)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) b)
(if (<= c 2.9e-29)
(* (- i) (* j (fma t y5 (* (- x) y1))))
(if (<= c 2.4e+116)
(* (* y4 (fma i (/ (* t z) y4) (* (- t) y2))) c)
(if (<= c 4.4e+273)
(* (* c y3) (fma y y4 (* (- y0) z)))
(* (* x (fma (- i) y (* y0 y2))) c))))))))
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 (c <= -4.9e+25) {
tmp = (c * y2) * fma(x, y0, (-t * y4));
} else if (c <= -2.45e-132) {
tmp = (-y0 * fma(j, x, (-k * z))) * b;
} else if (c <= 6.5e-281) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * b;
} else if (c <= 2.9e-29) {
tmp = -i * (j * fma(t, y5, (-x * y1)));
} else if (c <= 2.4e+116) {
tmp = (y4 * fma(i, ((t * z) / y4), (-t * y2))) * c;
} else if (c <= 4.4e+273) {
tmp = (c * y3) * fma(y, y4, (-y0 * z));
} else {
tmp = (x * fma(-i, y, (y0 * y2))) * c;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (c <= -4.9e+25) tmp = Float64(Float64(c * y2) * fma(x, y0, Float64(Float64(-t) * y4))); elseif (c <= -2.45e-132) tmp = Float64(Float64(Float64(-y0) * fma(j, x, Float64(Float64(-k) * z))) * b); elseif (c <= 6.5e-281) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * b); elseif (c <= 2.9e-29) tmp = Float64(Float64(-i) * Float64(j * fma(t, y5, Float64(Float64(-x) * y1)))); elseif (c <= 2.4e+116) tmp = Float64(Float64(y4 * fma(i, Float64(Float64(t * z) / y4), Float64(Float64(-t) * y2))) * c); elseif (c <= 4.4e+273) tmp = Float64(Float64(c * y3) * fma(y, y4, Float64(Float64(-y0) * z))); else tmp = Float64(Float64(x * fma(Float64(-i), y, Float64(y0 * y2))) * c); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[c, -4.9e+25], N[(N[(c * y2), $MachinePrecision] * N[(x * y0 + N[((-t) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -2.45e-132], N[(N[((-y0) * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 6.5e-281], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[c, 2.9e-29], N[((-i) * N[(j * N[(t * y5 + N[((-x) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.4e+116], N[(N[(y4 * N[(i * N[(N[(t * z), $MachinePrecision] / y4), $MachinePrecision] + N[((-t) * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[c, 4.4e+273], N[(N[(c * y3), $MachinePrecision] * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[((-i) * y + N[(y0 * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -4.9 \cdot 10^{+25}:\\
\;\;\;\;\left(c \cdot y2\right) \cdot \mathsf{fma}\left(x, y0, \left(-t\right) \cdot y4\right)\\
\mathbf{elif}\;c \leq -2.45 \cdot 10^{-132}:\\
\;\;\;\;\left(\left(-y0\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\right) \cdot b\\
\mathbf{elif}\;c \leq 6.5 \cdot 10^{-281}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{elif}\;c \leq 2.9 \cdot 10^{-29}:\\
\;\;\;\;\left(-i\right) \cdot \left(j \cdot \mathsf{fma}\left(t, y5, \left(-x\right) \cdot y1\right)\right)\\
\mathbf{elif}\;c \leq 2.4 \cdot 10^{+116}:\\
\;\;\;\;\left(y4 \cdot \mathsf{fma}\left(i, \frac{t \cdot z}{y4}, \left(-t\right) \cdot y2\right)\right) \cdot c\\
\mathbf{elif}\;c \leq 4.4 \cdot 10^{+273}:\\
\;\;\;\;\left(c \cdot y3\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot \mathsf{fma}\left(-i, y, y0 \cdot y2\right)\right) \cdot c\\
\end{array}
\end{array}
if c < -4.9000000000000001e25Initial program 33.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.1%
Taylor expanded in y2 around inf
Applied rewrites53.6%
if -4.9000000000000001e25 < c < -2.4499999999999999e-132Initial program 23.1%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites48.6%
Taylor expanded in t around inf
Applied rewrites19.7%
Taylor expanded in y0 around inf
Applied rewrites48.3%
if -2.4499999999999999e-132 < c < 6.5e-281Initial program 46.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.2%
Taylor expanded in t around inf
Applied rewrites48.7%
Taylor expanded in y4 around -inf
Applied rewrites50.7%
if 6.5e-281 < c < 2.90000000000000024e-29Initial program 36.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.5%
Taylor expanded in j around inf
Applied rewrites47.9%
if 2.90000000000000024e-29 < c < 2.4e116Initial program 30.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites42.8%
Taylor expanded in t around inf
Applied rewrites34.8%
Taylor expanded in y4 around inf
Applied rewrites43.3%
if 2.4e116 < c < 4.3999999999999998e273Initial program 12.5%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.5%
Taylor expanded in t around inf
Applied rewrites30.1%
Taylor expanded in y3 around inf
Applied rewrites67.2%
if 4.3999999999999998e273 < c Initial program 10.0%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.8%
Taylor expanded in x around inf
Applied rewrites84.4%
Final simplification52.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -3.3e+144)
(* (* (- x) (fma (- i) y1 (* b y0))) j)
(if (<= b -2.9e+76)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) b)
(if (<= b -2.4e-212)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= b 1.25e-112)
(* (fma y0 (fma x y2 (* (- y3) z)) (* (- i) (fma x y (* (- t) z)))) c)
(if (<= b 6.5e+86)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(* (* b (fma t y4 (* (- x) 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) {
double tmp;
if (b <= -3.3e+144) {
tmp = (-x * fma(-i, y1, (b * y0))) * j;
} else if (b <= -2.9e+76) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * b;
} else if (b <= -2.4e-212) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (b <= 1.25e-112) {
tmp = fma(y0, fma(x, y2, (-y3 * z)), (-i * fma(x, y, (-t * z)))) * c;
} else if (b <= 6.5e+86) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -3.3e+144) tmp = Float64(Float64(Float64(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j); elseif (b <= -2.9e+76) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * b); elseif (b <= -2.4e-212) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (b <= 1.25e-112) tmp = Float64(fma(y0, fma(x, y2, Float64(Float64(-y3) * z)), Float64(Float64(-i) * fma(x, y, Float64(Float64(-t) * z)))) * c); elseif (b <= 6.5e+86) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -3.3e+144], N[(N[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, -2.9e+76], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[b, -2.4e-212], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.25e-112], N[(N[(y0 * N[(x * y2 + N[((-y3) * z), $MachinePrecision]), $MachinePrecision] + N[((-i) * N[(x * y + N[((-t) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 6.5e+86], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.3 \cdot 10^{+144}:\\
\;\;\;\;\left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{elif}\;b \leq -2.9 \cdot 10^{+76}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{elif}\;b \leq -2.4 \cdot 10^{-212}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;b \leq 1.25 \cdot 10^{-112}:\\
\;\;\;\;\mathsf{fma}\left(y0, \mathsf{fma}\left(x, y2, \left(-y3\right) \cdot z\right), \left(-i\right) \cdot \mathsf{fma}\left(x, y, \left(-t\right) \cdot z\right)\right) \cdot c\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+86}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -3.3e144Initial program 26.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in x around inf
Applied rewrites56.1%
if -3.3e144 < b < -2.9000000000000002e76Initial program 38.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.7%
Taylor expanded in t around inf
Applied rewrites77.6%
Taylor expanded in y4 around -inf
Applied rewrites77.8%
if -2.9000000000000002e76 < b < -2.39999999999999989e-212Initial program 37.2%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites39.6%
Taylor expanded in y around -inf
Applied rewrites38.4%
if -2.39999999999999989e-212 < b < 1.25000000000000011e-112Initial program 37.9%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.8%
Taylor expanded in t around inf
Applied rewrites31.1%
Taylor expanded in y4 around 0
Applied rewrites45.3%
if 1.25000000000000011e-112 < b < 6.49999999999999996e86Initial program 27.9%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites54.2%
Taylor expanded in y1 around -inf
Applied rewrites56.4%
if 6.49999999999999996e86 < b Initial program 20.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites64.4%
Final simplification52.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y -8.8e+102)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= y 2.6e+180)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* (* (* y0 z) k) b))
(* (* y (fma -1.0 (* k y4) (* a x))) 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 (y <= -8.8e+102) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (y <= 2.6e+180) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (((y0 * z) * k) * b));
} else {
tmp = (y * fma(-1.0, (k * y4), (a * x))) * 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 (y <= -8.8e+102) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (y <= 2.6e+180) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(Float64(Float64(y0 * z) * k) * b)); else tmp = Float64(Float64(y * fma(-1.0, Float64(k * y4), Float64(a * x))) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y, -8.8e+102], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.6e+180], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(y0 * z), $MachinePrecision] * k), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision], N[(N[(y * N[(-1.0 * N[(k * y4), $MachinePrecision] + N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.8 \cdot 10^{+102}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;y \leq 2.6 \cdot 10^{+180}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), \left(\left(y0 \cdot z\right) \cdot k\right) \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot \mathsf{fma}\left(-1, k \cdot y4, a \cdot x\right)\right) \cdot b\\
\end{array}
\end{array}
if y < -8.8000000000000003e102Initial program 27.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.2%
Taylor expanded in y around -inf
Applied rewrites57.5%
if -8.8000000000000003e102 < y < 2.60000000000000021e180Initial program 33.6%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites38.6%
Taylor expanded in y0 around inf
Applied rewrites47.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites50.1%
if 2.60000000000000021e180 < y Initial program 21.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in y around inf
Applied rewrites60.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y -8.8e+102)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= y 2.6e+180)
(fma
(fma y4 y1 (* (- y0) y5))
(fma y2 k (* (- y3) j))
(* z (* y0 (* b k))))
(* (* y (fma -1.0 (* k y4) (* a x))) 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 (y <= -8.8e+102) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (y <= 2.6e+180) {
tmp = fma(fma(y4, y1, (-y0 * y5)), fma(y2, k, (-y3 * j)), (z * (y0 * (b * k))));
} else {
tmp = (y * fma(-1.0, (k * y4), (a * x))) * 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 (y <= -8.8e+102) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (y <= 2.6e+180) tmp = fma(fma(y4, y1, Float64(Float64(-y0) * y5)), fma(y2, k, Float64(Float64(-y3) * j)), Float64(z * Float64(y0 * Float64(b * k)))); else tmp = Float64(Float64(y * fma(-1.0, Float64(k * y4), Float64(a * x))) * b); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y, -8.8e+102], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.6e+180], N[(N[(y4 * y1 + N[((-y0) * y5), $MachinePrecision]), $MachinePrecision] * N[(y2 * k + N[((-y3) * j), $MachinePrecision]), $MachinePrecision] + N[(z * N[(y0 * N[(b * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * N[(-1.0 * N[(k * y4), $MachinePrecision] + N[(a * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8.8 \cdot 10^{+102}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;y \leq 2.6 \cdot 10^{+180}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(y4, y1, \left(-y0\right) \cdot y5\right), \mathsf{fma}\left(y2, k, \left(-y3\right) \cdot j\right), z \cdot \left(y0 \cdot \left(b \cdot k\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot \mathsf{fma}\left(-1, k \cdot y4, a \cdot x\right)\right) \cdot b\\
\end{array}
\end{array}
if y < -8.8000000000000003e102Initial program 27.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites48.2%
Taylor expanded in y around -inf
Applied rewrites57.5%
if -8.8000000000000003e102 < y < 2.60000000000000021e180Initial program 33.6%
Taylor expanded in k around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
fp-cancel-sub-sign-invN/A
*-commutativeN/A
lower-fma.f64N/A
lower-*.f64N/A
lower-neg.f64N/A
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
fp-cancel-sub-sign-invN/A
Applied rewrites38.6%
Taylor expanded in y0 around inf
Applied rewrites47.5%
lift-+.f64N/A
+-commutativeN/A
Applied rewrites50.1%
Applied rewrites48.5%
if 2.60000000000000021e180 < y Initial program 21.7%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in y around inf
Applied rewrites60.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -3.3e+144)
(* (* (- x) (fma (- i) y1 (* b y0))) j)
(if (<= b -2.9e+76)
(* (* t (* (- y4) (fma a (/ z y4) (- j)))) b)
(if (<= b 6e-72)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= b 6.5e+86)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(* (* b (fma t y4 (* (- x) 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) {
double tmp;
if (b <= -3.3e+144) {
tmp = (-x * fma(-i, y1, (b * y0))) * j;
} else if (b <= -2.9e+76) {
tmp = (t * (-y4 * fma(a, (z / y4), -j))) * b;
} else if (b <= 6e-72) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (b <= 6.5e+86) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -3.3e+144) tmp = Float64(Float64(Float64(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j); elseif (b <= -2.9e+76) tmp = Float64(Float64(t * Float64(Float64(-y4) * fma(a, Float64(z / y4), Float64(-j)))) * b); elseif (b <= 6e-72) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (b <= 6.5e+86) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -3.3e+144], N[(N[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, -2.9e+76], N[(N[(t * N[((-y4) * N[(a * N[(z / y4), $MachinePrecision] + (-j)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[b, 6e-72], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e+86], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.3 \cdot 10^{+144}:\\
\;\;\;\;\left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{elif}\;b \leq -2.9 \cdot 10^{+76}:\\
\;\;\;\;\left(t \cdot \left(\left(-y4\right) \cdot \mathsf{fma}\left(a, \frac{z}{y4}, -j\right)\right)\right) \cdot b\\
\mathbf{elif}\;b \leq 6 \cdot 10^{-72}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+86}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -3.3e144Initial program 26.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in x around inf
Applied rewrites56.1%
if -3.3e144 < b < -2.9000000000000002e76Initial program 38.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.7%
Taylor expanded in t around inf
Applied rewrites77.6%
Taylor expanded in y4 around -inf
Applied rewrites77.8%
if -2.9000000000000002e76 < b < 6e-72Initial program 36.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites36.0%
Taylor expanded in y around -inf
Applied rewrites36.2%
if 6e-72 < b < 6.49999999999999996e86Initial program 28.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in y1 around -inf
Applied rewrites57.6%
if 6.49999999999999996e86 < b Initial program 20.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites64.4%
Final simplification49.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -3.3e+144)
(* (* (- x) (fma (- i) y1 (* b y0))) j)
(if (<= b -3.4e+77)
(* (* t (fma -1.0 (* a z) (* j y4))) b)
(if (<= b 6e-72)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= b 6.5e+86)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(* (* b (fma t y4 (* (- x) 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) {
double tmp;
if (b <= -3.3e+144) {
tmp = (-x * fma(-i, y1, (b * y0))) * j;
} else if (b <= -3.4e+77) {
tmp = (t * fma(-1.0, (a * z), (j * y4))) * b;
} else if (b <= 6e-72) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (b <= 6.5e+86) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -3.3e+144) tmp = Float64(Float64(Float64(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j); elseif (b <= -3.4e+77) tmp = Float64(Float64(t * fma(-1.0, Float64(a * z), Float64(j * y4))) * b); elseif (b <= 6e-72) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (b <= 6.5e+86) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -3.3e+144], N[(N[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, -3.4e+77], N[(N[(t * N[(-1.0 * N[(a * z), $MachinePrecision] + N[(j * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[b, 6e-72], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e+86], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.3 \cdot 10^{+144}:\\
\;\;\;\;\left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{elif}\;b \leq -3.4 \cdot 10^{+77}:\\
\;\;\;\;\left(t \cdot \mathsf{fma}\left(-1, a \cdot z, j \cdot y4\right)\right) \cdot b\\
\mathbf{elif}\;b \leq 6 \cdot 10^{-72}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+86}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -3.3e144Initial program 26.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in x around inf
Applied rewrites56.1%
if -3.3e144 < b < -3.39999999999999997e77Initial program 38.9%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites69.7%
Taylor expanded in t around inf
Applied rewrites77.6%
if -3.39999999999999997e77 < b < 6e-72Initial program 36.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites36.0%
Taylor expanded in y around -inf
Applied rewrites36.2%
if 6e-72 < b < 6.49999999999999996e86Initial program 28.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in y1 around -inf
Applied rewrites57.6%
if 6.49999999999999996e86 < b Initial program 20.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites64.4%
Final simplification49.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -1.95e+147)
(* (* (- x) (fma (- i) y1 (* b y0))) j)
(if (<= b -6e+57)
(* (* t (fma (- i) y5 (* b y4))) j)
(if (<= b 6e-72)
(* i (* y (fma -1.0 (* c x) (* k y5))))
(if (<= b 6.5e+86)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(* (* b (fma t y4 (* (- x) 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) {
double tmp;
if (b <= -1.95e+147) {
tmp = (-x * fma(-i, y1, (b * y0))) * j;
} else if (b <= -6e+57) {
tmp = (t * fma(-i, y5, (b * y4))) * j;
} else if (b <= 6e-72) {
tmp = i * (y * fma(-1.0, (c * x), (k * y5)));
} else if (b <= 6.5e+86) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -1.95e+147) tmp = Float64(Float64(Float64(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j); elseif (b <= -6e+57) tmp = Float64(Float64(t * fma(Float64(-i), y5, Float64(b * y4))) * j); elseif (b <= 6e-72) tmp = Float64(i * Float64(y * fma(-1.0, Float64(c * x), Float64(k * y5)))); elseif (b <= 6.5e+86) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -1.95e+147], N[(N[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, -6e+57], N[(N[(t * N[((-i) * y5 + N[(b * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, 6e-72], N[(i * N[(y * N[(-1.0 * N[(c * x), $MachinePrecision] + N[(k * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e+86], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.95 \cdot 10^{+147}:\\
\;\;\;\;\left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{elif}\;b \leq -6 \cdot 10^{+57}:\\
\;\;\;\;\left(t \cdot \mathsf{fma}\left(-i, y5, b \cdot y4\right)\right) \cdot j\\
\mathbf{elif}\;b \leq 6 \cdot 10^{-72}:\\
\;\;\;\;i \cdot \left(y \cdot \mathsf{fma}\left(-1, c \cdot x, k \cdot y5\right)\right)\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+86}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -1.95000000000000008e147Initial program 26.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in x around inf
Applied rewrites56.1%
if -1.95000000000000008e147 < b < -5.9999999999999999e57Initial program 40.4%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.9%
Taylor expanded in t around inf
Applied rewrites73.8%
if -5.9999999999999999e57 < b < 6e-72Initial program 36.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.7%
Taylor expanded in y around -inf
Applied rewrites36.0%
if 6e-72 < b < 6.49999999999999996e86Initial program 28.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in y1 around -inf
Applied rewrites57.6%
if 6.49999999999999996e86 < b Initial program 20.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites64.4%
Final simplification49.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -1.95e+147)
(* (* (- x) (fma (- i) y1 (* b y0))) j)
(if (<= b -5.6e+56)
(* (* t (fma (- i) y5 (* b y4))) j)
(if (<= b 3.25e-74)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 6.5e+86)
(* (* (- y1) (fma y3 y4 (* (- i) x))) j)
(* (* b (fma t y4 (* (- x) 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) {
double tmp;
if (b <= -1.95e+147) {
tmp = (-x * fma(-i, y1, (b * y0))) * j;
} else if (b <= -5.6e+56) {
tmp = (t * fma(-i, y5, (b * y4))) * j;
} else if (b <= 3.25e-74) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 6.5e+86) {
tmp = (-y1 * fma(y3, y4, (-i * x))) * j;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -1.95e+147) tmp = Float64(Float64(Float64(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j); elseif (b <= -5.6e+56) tmp = Float64(Float64(t * fma(Float64(-i), y5, Float64(b * y4))) * j); elseif (b <= 3.25e-74) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 6.5e+86) tmp = Float64(Float64(Float64(-y1) * fma(y3, y4, Float64(Float64(-i) * x))) * j); else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -1.95e+147], N[(N[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, -5.6e+56], N[(N[(t * N[((-i) * y5 + N[(b * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, 3.25e-74], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e+86], N[(N[((-y1) * N[(y3 * y4 + N[((-i) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.95 \cdot 10^{+147}:\\
\;\;\;\;\left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{elif}\;b \leq -5.6 \cdot 10^{+56}:\\
\;\;\;\;\left(t \cdot \mathsf{fma}\left(-i, y5, b \cdot y4\right)\right) \cdot j\\
\mathbf{elif}\;b \leq 3.25 \cdot 10^{-74}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+86}:\\
\;\;\;\;\left(\left(-y1\right) \cdot \mathsf{fma}\left(y3, y4, \left(-i\right) \cdot x\right)\right) \cdot j\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -1.95000000000000008e147Initial program 26.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in x around inf
Applied rewrites56.1%
if -1.95000000000000008e147 < b < -5.60000000000000017e56Initial program 40.4%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.9%
Taylor expanded in t around inf
Applied rewrites73.8%
if -5.60000000000000017e56 < b < 3.2500000000000001e-74Initial program 36.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.7%
Taylor expanded in k around -inf
Applied rewrites29.5%
Taylor expanded in y around -inf
Applied rewrites35.9%
if 3.2500000000000001e-74 < b < 6.49999999999999996e86Initial program 28.6%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.2%
Taylor expanded in y1 around -inf
Applied rewrites57.6%
if 6.49999999999999996e86 < b Initial program 20.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites52.4%
Taylor expanded in b around inf
Applied rewrites64.4%
Final simplification49.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* (- x) (fma (- i) y1 (* b y0))) j)))
(if (<= b -1.95e+147)
t_1
(if (<= b -5.6e+56)
(* (* t (fma (- i) y5 (* b y4))) j)
(if (<= b 2.65e-73)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 2.1e+68) t_1 (* (* b (fma t y4 (* (- x) 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) {
double t_1 = (-x * fma(-i, y1, (b * y0))) * j;
double tmp;
if (b <= -1.95e+147) {
tmp = t_1;
} else if (b <= -5.6e+56) {
tmp = (t * fma(-i, y5, (b * y4))) * j;
} else if (b <= 2.65e-73) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 2.1e+68) {
tmp = t_1;
} else {
tmp = (b * fma(t, y4, (-x * y0))) * j;
}
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(-x) * fma(Float64(-i), y1, Float64(b * y0))) * j) tmp = 0.0 if (b <= -1.95e+147) tmp = t_1; elseif (b <= -5.6e+56) tmp = Float64(Float64(t * fma(Float64(-i), y5, Float64(b * y4))) * j); elseif (b <= 2.65e-73) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 2.1e+68) tmp = t_1; else tmp = Float64(Float64(b * fma(t, y4, Float64(Float64(-x) * y0))) * j); 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[((-x) * N[((-i) * y1 + N[(b * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[b, -1.95e+147], t$95$1, If[LessEqual[b, -5.6e+56], N[(N[(t * N[((-i) * y5 + N[(b * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision], If[LessEqual[b, 2.65e-73], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.1e+68], t$95$1, N[(N[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\left(-x\right) \cdot \mathsf{fma}\left(-i, y1, b \cdot y0\right)\right) \cdot j\\
\mathbf{if}\;b \leq -1.95 \cdot 10^{+147}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.6 \cdot 10^{+56}:\\
\;\;\;\;\left(t \cdot \mathsf{fma}\left(-i, y5, b \cdot y4\right)\right) \cdot j\\
\mathbf{elif}\;b \leq 2.65 \cdot 10^{-73}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{+68}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\end{array}
\end{array}
if b < -1.95000000000000008e147 or 2.64999999999999986e-73 < b < 2.10000000000000001e68Initial program 27.2%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.8%
Taylor expanded in x around inf
Applied rewrites53.8%
if -1.95000000000000008e147 < b < -5.60000000000000017e56Initial program 40.4%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites53.9%
Taylor expanded in t around inf
Applied rewrites73.8%
if -5.60000000000000017e56 < b < 2.64999999999999986e-73Initial program 36.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.7%
Taylor expanded in k around -inf
Applied rewrites29.5%
Taylor expanded in y around -inf
Applied rewrites35.9%
if 2.10000000000000001e68 < b Initial program 21.5%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.3%
Taylor expanded in b around inf
Applied rewrites62.6%
Final simplification47.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* b j) (* t y4))))
(if (<= b -6e+78)
t_1
(if (<= b 6.8e-305)
(* i (* (* y5 k) y))
(if (<= b 3.3e-97)
(* (* i (* t z)) c)
(if (<= b 9.6e+67) (* (- i) (* j (* (- x) y1))) 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 = (b * j) * (t * y4);
double tmp;
if (b <= -6e+78) {
tmp = t_1;
} else if (b <= 6.8e-305) {
tmp = i * ((y5 * k) * y);
} else if (b <= 3.3e-97) {
tmp = (i * (t * z)) * c;
} else if (b <= 9.6e+67) {
tmp = -i * (j * (-x * y1));
} 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 = (b * j) * (t * y4)
if (b <= (-6d+78)) then
tmp = t_1
else if (b <= 6.8d-305) then
tmp = i * ((y5 * k) * y)
else if (b <= 3.3d-97) then
tmp = (i * (t * z)) * c
else if (b <= 9.6d+67) then
tmp = -i * (j * (-x * y1))
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 = (b * j) * (t * y4);
double tmp;
if (b <= -6e+78) {
tmp = t_1;
} else if (b <= 6.8e-305) {
tmp = i * ((y5 * k) * y);
} else if (b <= 3.3e-97) {
tmp = (i * (t * z)) * c;
} else if (b <= 9.6e+67) {
tmp = -i * (j * (-x * y1));
} 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 = (b * j) * (t * y4) tmp = 0 if b <= -6e+78: tmp = t_1 elif b <= 6.8e-305: tmp = i * ((y5 * k) * y) elif b <= 3.3e-97: tmp = (i * (t * z)) * c elif b <= 9.6e+67: tmp = -i * (j * (-x * y1)) 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(b * j) * Float64(t * y4)) tmp = 0.0 if (b <= -6e+78) tmp = t_1; elseif (b <= 6.8e-305) tmp = Float64(i * Float64(Float64(y5 * k) * y)); elseif (b <= 3.3e-97) tmp = Float64(Float64(i * Float64(t * z)) * c); elseif (b <= 9.6e+67) tmp = Float64(Float64(-i) * Float64(j * Float64(Float64(-x) * y1))); 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 = (b * j) * (t * y4); tmp = 0.0; if (b <= -6e+78) tmp = t_1; elseif (b <= 6.8e-305) tmp = i * ((y5 * k) * y); elseif (b <= 3.3e-97) tmp = (i * (t * z)) * c; elseif (b <= 9.6e+67) tmp = -i * (j * (-x * y1)); 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[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6e+78], t$95$1, If[LessEqual[b, 6.8e-305], N[(i * N[(N[(y5 * k), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.3e-97], N[(N[(i * N[(t * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], If[LessEqual[b, 9.6e+67], N[((-i) * N[(j * N[((-x) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\mathbf{if}\;b \leq -6 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 6.8 \cdot 10^{-305}:\\
\;\;\;\;i \cdot \left(\left(y5 \cdot k\right) \cdot y\right)\\
\mathbf{elif}\;b \leq 3.3 \cdot 10^{-97}:\\
\;\;\;\;\left(i \cdot \left(t \cdot z\right)\right) \cdot c\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+67}:\\
\;\;\;\;\left(-i\right) \cdot \left(j \cdot \left(\left(-x\right) \cdot y1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.99999999999999964e78 or 9.60000000000000007e67 < b Initial program 25.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.2%
Taylor expanded in t around inf
Applied rewrites47.2%
Taylor expanded in j around inf
Applied rewrites53.7%
Taylor expanded in x around 0
Applied rewrites40.1%
if -5.99999999999999964e78 < b < 6.8000000000000001e-305Initial program 37.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites38.1%
Taylor expanded in k around -inf
Applied rewrites32.2%
Taylor expanded in y around inf
Applied rewrites28.7%
Applied rewrites31.1%
if 6.8000000000000001e-305 < b < 3.3000000000000001e-97Initial program 36.7%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites39.8%
Taylor expanded in t around inf
Applied rewrites33.3%
Taylor expanded in z around inf
Applied rewrites33.3%
if 3.3000000000000001e-97 < b < 9.60000000000000007e67Initial program 29.7%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites46.4%
Taylor expanded in j around inf
Applied rewrites49.5%
Taylor expanded in x around inf
Applied rewrites38.8%
Final simplification36.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* b (fma t y4 (* (- x) y0))) j)))
(if (<= b -2.55e+76)
t_1
(if (<= b -5.2e-234)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 2.15e+68) (* (* i y1) (fma j x (* (- k) z))) 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 = (b * fma(t, y4, (-x * y0))) * j;
double tmp;
if (b <= -2.55e+76) {
tmp = t_1;
} else if (b <= -5.2e-234) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 2.15e+68) {
tmp = (i * y1) * fma(j, x, (-k * z));
} 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(b * fma(t, y4, Float64(Float64(-x) * y0))) * j) tmp = 0.0 if (b <= -2.55e+76) tmp = t_1; elseif (b <= -5.2e-234) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 2.15e+68) tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); 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[(b * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]}, If[LessEqual[b, -2.55e+76], t$95$1, If[LessEqual[b, -5.2e-234], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.15e+68], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\right) \cdot j\\
\mathbf{if}\;b \leq -2.55 \cdot 10^{+76}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.2 \cdot 10^{-234}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 2.15 \cdot 10^{+68}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -2.5500000000000001e76 or 2.1500000000000001e68 < b Initial program 25.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites55.5%
Taylor expanded in b around inf
Applied rewrites56.1%
if -2.5500000000000001e76 < b < -5.19999999999999978e-234Initial program 38.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.9%
Taylor expanded in k around -inf
Applied rewrites31.8%
Taylor expanded in y around -inf
Applied rewrites39.2%
if -5.19999999999999978e-234 < b < 2.1500000000000001e68Initial program 32.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.0%
Taylor expanded in k around -inf
Applied rewrites26.1%
Taylor expanded in y1 around inf
Applied rewrites37.0%
Final simplification44.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* b j) (fma t y4 (* (- x) y0)))))
(if (<= b -5.2e+77)
t_1
(if (<= b -5.2e-234)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 2.15e+68) (* (* i y1) (fma j x (* (- k) z))) 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 = (b * j) * fma(t, y4, (-x * y0));
double tmp;
if (b <= -5.2e+77) {
tmp = t_1;
} else if (b <= -5.2e-234) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 2.15e+68) {
tmp = (i * y1) * fma(j, x, (-k * z));
} 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(b * j) * fma(t, y4, Float64(Float64(-x) * y0))) tmp = 0.0 if (b <= -5.2e+77) tmp = t_1; elseif (b <= -5.2e-234) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 2.15e+68) tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); 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[(b * j), $MachinePrecision] * N[(t * y4 + N[((-x) * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.2e+77], t$95$1, If[LessEqual[b, -5.2e-234], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.15e+68], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot j\right) \cdot \mathsf{fma}\left(t, y4, \left(-x\right) \cdot y0\right)\\
\mathbf{if}\;b \leq -5.2 \cdot 10^{+77}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.2 \cdot 10^{-234}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 2.15 \cdot 10^{+68}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.2000000000000004e77 or 2.1500000000000001e68 < b Initial program 25.7%
Taylor expanded in j around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites55.5%
Taylor expanded in b around inf
Applied rewrites53.2%
if -5.2000000000000004e77 < b < -5.19999999999999978e-234Initial program 38.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.9%
Taylor expanded in k around -inf
Applied rewrites31.8%
Taylor expanded in y around -inf
Applied rewrites39.2%
if -5.19999999999999978e-234 < b < 2.1500000000000001e68Initial program 32.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.0%
Taylor expanded in k around -inf
Applied rewrites26.1%
Taylor expanded in y1 around inf
Applied rewrites37.0%
Final simplification43.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* c y2) (fma x y0 (* (- t) y4)))))
(if (<= c -3.6e+26)
t_1
(if (<= c 1.1e-126)
(* (* i y1) (fma j x (* (- k) z)))
(if (<= c 1.05e+256) (* (* c y3) (fma y y4 (* (- y0) z))) 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 = (c * y2) * fma(x, y0, (-t * y4));
double tmp;
if (c <= -3.6e+26) {
tmp = t_1;
} else if (c <= 1.1e-126) {
tmp = (i * y1) * fma(j, x, (-k * z));
} else if (c <= 1.05e+256) {
tmp = (c * y3) * fma(y, y4, (-y0 * z));
} 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(c * y2) * fma(x, y0, Float64(Float64(-t) * y4))) tmp = 0.0 if (c <= -3.6e+26) tmp = t_1; elseif (c <= 1.1e-126) tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); elseif (c <= 1.05e+256) tmp = Float64(Float64(c * y3) * fma(y, y4, Float64(Float64(-y0) * z))); 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[(c * y2), $MachinePrecision] * N[(x * y0 + N[((-t) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.6e+26], t$95$1, If[LessEqual[c, 1.1e-126], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.05e+256], N[(N[(c * y3), $MachinePrecision] * N[(y * y4 + N[((-y0) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(c \cdot y2\right) \cdot \mathsf{fma}\left(x, y0, \left(-t\right) \cdot y4\right)\\
\mathbf{if}\;c \leq -3.6 \cdot 10^{+26}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 1.1 \cdot 10^{-126}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\mathbf{elif}\;c \leq 1.05 \cdot 10^{+256}:\\
\;\;\;\;\left(c \cdot y3\right) \cdot \mathsf{fma}\left(y, y4, \left(-y0\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -3.60000000000000024e26 or 1.05e256 < c Initial program 30.0%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites51.8%
Taylor expanded in y2 around inf
Applied rewrites57.8%
if -3.60000000000000024e26 < c < 1.10000000000000007e-126Initial program 36.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites38.1%
Taylor expanded in k around -inf
Applied rewrites29.8%
Taylor expanded in y1 around inf
Applied rewrites35.3%
if 1.10000000000000007e-126 < c < 1.05e256Initial program 23.0%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.3%
Taylor expanded in t around inf
Applied rewrites26.9%
Taylor expanded in y3 around inf
Applied rewrites39.7%
Final simplification41.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= j -2.2e+66)
(* (* (* j t) y4) b)
(if (<= j -1e-114)
(* (* c y0) (fma x y2 (* (- y3) z)))
(if (<= j 2.5e+25)
(* (* c t) (fma i z (* (- y2) y4)))
(* (* i y1) (fma j x (* (- k) z)))))))
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 <= -2.2e+66) {
tmp = ((j * t) * y4) * b;
} else if (j <= -1e-114) {
tmp = (c * y0) * fma(x, y2, (-y3 * z));
} else if (j <= 2.5e+25) {
tmp = (c * t) * fma(i, z, (-y2 * y4));
} else {
tmp = (i * y1) * fma(j, x, (-k * z));
}
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 <= -2.2e+66) tmp = Float64(Float64(Float64(j * t) * y4) * b); elseif (j <= -1e-114) tmp = Float64(Float64(c * y0) * fma(x, y2, Float64(Float64(-y3) * z))); elseif (j <= 2.5e+25) tmp = Float64(Float64(c * t) * fma(i, z, Float64(Float64(-y2) * y4))); else tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[j, -2.2e+66], N[(N[(N[(j * t), $MachinePrecision] * y4), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, -1e-114], N[(N[(c * y0), $MachinePrecision] * N[(x * y2 + N[((-y3) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.5e+25], N[(N[(c * t), $MachinePrecision] * N[(i * z + N[((-y2) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -2.2 \cdot 10^{+66}:\\
\;\;\;\;\left(\left(j \cdot t\right) \cdot y4\right) \cdot b\\
\mathbf{elif}\;j \leq -1 \cdot 10^{-114}:\\
\;\;\;\;\left(c \cdot y0\right) \cdot \mathsf{fma}\left(x, y2, \left(-y3\right) \cdot z\right)\\
\mathbf{elif}\;j \leq 2.5 \cdot 10^{+25}:\\
\;\;\;\;\left(c \cdot t\right) \cdot \mathsf{fma}\left(i, z, \left(-y2\right) \cdot y4\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\end{array}
\end{array}
if j < -2.1999999999999998e66Initial program 26.4%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites43.8%
Taylor expanded in t around inf
Applied rewrites44.3%
Taylor expanded in z around 0
Applied rewrites39.0%
if -2.1999999999999998e66 < j < -1.0000000000000001e-114Initial program 39.6%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.6%
Taylor expanded in t around inf
Applied rewrites19.9%
Taylor expanded in y0 around inf
Applied rewrites38.1%
if -1.0000000000000001e-114 < j < 2.50000000000000012e25Initial program 41.3%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites35.8%
Taylor expanded in t around inf
Applied rewrites32.3%
if 2.50000000000000012e25 < j Initial program 17.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.5%
Taylor expanded in k around -inf
Applied rewrites32.8%
Taylor expanded in y1 around inf
Applied rewrites53.7%
Final simplification40.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= j -1.36e+55)
(* (* (* j t) y4) b)
(if (<= j -3e-132)
(* (* t (* (- a) z)) b)
(if (<= j 2.5e+25)
(* (* c t) (fma i z (* (- y2) y4)))
(* (* i y1) (fma j x (* (- k) z)))))))
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 <= -1.36e+55) {
tmp = ((j * t) * y4) * b;
} else if (j <= -3e-132) {
tmp = (t * (-a * z)) * b;
} else if (j <= 2.5e+25) {
tmp = (c * t) * fma(i, z, (-y2 * y4));
} else {
tmp = (i * y1) * fma(j, x, (-k * z));
}
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 <= -1.36e+55) tmp = Float64(Float64(Float64(j * t) * y4) * b); elseif (j <= -3e-132) tmp = Float64(Float64(t * Float64(Float64(-a) * z)) * b); elseif (j <= 2.5e+25) tmp = Float64(Float64(c * t) * fma(i, z, Float64(Float64(-y2) * y4))); else tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[j, -1.36e+55], N[(N[(N[(j * t), $MachinePrecision] * y4), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, -3e-132], N[(N[(t * N[((-a) * z), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], If[LessEqual[j, 2.5e+25], N[(N[(c * t), $MachinePrecision] * N[(i * z + N[((-y2) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.36 \cdot 10^{+55}:\\
\;\;\;\;\left(\left(j \cdot t\right) \cdot y4\right) \cdot b\\
\mathbf{elif}\;j \leq -3 \cdot 10^{-132}:\\
\;\;\;\;\left(t \cdot \left(\left(-a\right) \cdot z\right)\right) \cdot b\\
\mathbf{elif}\;j \leq 2.5 \cdot 10^{+25}:\\
\;\;\;\;\left(c \cdot t\right) \cdot \mathsf{fma}\left(i, z, \left(-y2\right) \cdot y4\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\end{array}
\end{array}
if j < -1.36e55Initial program 27.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites44.0%
Taylor expanded in t around inf
Applied rewrites42.8%
Taylor expanded in z around 0
Applied rewrites37.6%
if -1.36e55 < j < -3e-132Initial program 40.2%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites35.2%
Taylor expanded in t around inf
Applied rewrites32.3%
Taylor expanded in z around inf
Applied rewrites32.6%
if -3e-132 < j < 2.50000000000000012e25Initial program 40.9%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites37.2%
Taylor expanded in t around inf
Applied rewrites33.6%
if 2.50000000000000012e25 < j Initial program 17.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.5%
Taylor expanded in k around -inf
Applied rewrites32.8%
Taylor expanded in y1 around inf
Applied rewrites53.7%
Final simplification39.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* i y1) (fma j x (* (- k) z)))))
(if (<= b -2.3e-27)
t_1
(if (<= b -5.2e-234)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 3.1e+70) t_1 (* (* b j) (* t 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 = (i * y1) * fma(j, x, (-k * z));
double tmp;
if (b <= -2.3e-27) {
tmp = t_1;
} else if (b <= -5.2e-234) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 3.1e+70) {
tmp = t_1;
} else {
tmp = (b * j) * (t * 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(i * y1) * fma(j, x, Float64(Float64(-k) * z))) tmp = 0.0 if (b <= -2.3e-27) tmp = t_1; elseif (b <= -5.2e-234) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 3.1e+70) tmp = t_1; else tmp = Float64(Float64(b * j) * Float64(t * 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[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.3e-27], t$95$1, If[LessEqual[b, -5.2e-234], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.1e+70], t$95$1, N[(N[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\mathbf{if}\;b \leq -2.3 \cdot 10^{-27}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.2 \cdot 10^{-234}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 3.1 \cdot 10^{+70}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\end{array}
\end{array}
if b < -2.2999999999999999e-27 or -5.19999999999999978e-234 < b < 3.1000000000000003e70Initial program 33.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites41.3%
Taylor expanded in k around -inf
Applied rewrites23.5%
Taylor expanded in y1 around inf
Applied rewrites37.2%
if -2.2999999999999999e-27 < b < -5.19999999999999978e-234Initial program 35.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites30.6%
Taylor expanded in k around -inf
Applied rewrites32.6%
Taylor expanded in y around -inf
Applied rewrites40.5%
if 3.1000000000000003e70 < b Initial program 21.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites66.1%
Taylor expanded in t around inf
Applied rewrites49.8%
Taylor expanded in j around inf
Applied rewrites56.6%
Taylor expanded in x around 0
Applied rewrites43.5%
Final simplification39.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* b j) (* t y4))))
(if (<= b -6.2e+78)
t_1
(if (<= b 2.65e-73)
(* (* i y) (fma k y5 (* (- c) x)))
(if (<= b 9.6e+67) (* (- i) (* j (* (- x) y1))) 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 = (b * j) * (t * y4);
double tmp;
if (b <= -6.2e+78) {
tmp = t_1;
} else if (b <= 2.65e-73) {
tmp = (i * y) * fma(k, y5, (-c * x));
} else if (b <= 9.6e+67) {
tmp = -i * (j * (-x * y1));
} 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(b * j) * Float64(t * y4)) tmp = 0.0 if (b <= -6.2e+78) tmp = t_1; elseif (b <= 2.65e-73) tmp = Float64(Float64(i * y) * fma(k, y5, Float64(Float64(-c) * x))); elseif (b <= 9.6e+67) tmp = Float64(Float64(-i) * Float64(j * Float64(Float64(-x) * y1))); 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[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.2e+78], t$95$1, If[LessEqual[b, 2.65e-73], N[(N[(i * y), $MachinePrecision] * N[(k * y5 + N[((-c) * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.6e+67], N[((-i) * N[(j * N[((-x) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\mathbf{if}\;b \leq -6.2 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2.65 \cdot 10^{-73}:\\
\;\;\;\;\left(i \cdot y\right) \cdot \mathsf{fma}\left(k, y5, \left(-c\right) \cdot x\right)\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+67}:\\
\;\;\;\;\left(-i\right) \cdot \left(j \cdot \left(\left(-x\right) \cdot y1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -6.2e78 or 9.60000000000000007e67 < b Initial program 25.0%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites59.2%
Taylor expanded in t around inf
Applied rewrites47.2%
Taylor expanded in j around inf
Applied rewrites53.7%
Taylor expanded in x around 0
Applied rewrites40.1%
if -6.2e78 < b < 2.64999999999999986e-73Initial program 37.3%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.7%
Taylor expanded in k around -inf
Applied rewrites29.6%
Taylor expanded in y around -inf
Applied rewrites35.9%
if 2.64999999999999986e-73 < b < 9.60000000000000007e67Initial program 28.1%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites50.4%
Taylor expanded in j around inf
Applied rewrites50.9%
Taylor expanded in x around inf
Applied rewrites38.6%
Final simplification37.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= b -3.8e+180)
(* (* b j) (* (- x) y0))
(if (<= b 1.48e-99)
(* (* i k) (fma y y5 (* (- y1) z)))
(if (<= b 9.6e+67) (* (- i) (* j (* (- x) y1))) (* (* b j) (* t 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 (b <= -3.8e+180) {
tmp = (b * j) * (-x * y0);
} else if (b <= 1.48e-99) {
tmp = (i * k) * fma(y, y5, (-y1 * z));
} else if (b <= 9.6e+67) {
tmp = -i * (j * (-x * y1));
} else {
tmp = (b * j) * (t * 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 (b <= -3.8e+180) tmp = Float64(Float64(b * j) * Float64(Float64(-x) * y0)); elseif (b <= 1.48e-99) tmp = Float64(Float64(i * k) * fma(y, y5, Float64(Float64(-y1) * z))); elseif (b <= 9.6e+67) tmp = Float64(Float64(-i) * Float64(j * Float64(Float64(-x) * y1))); else tmp = Float64(Float64(b * j) * Float64(t * y4)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -3.8e+180], N[(N[(b * j), $MachinePrecision] * N[((-x) * y0), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.48e-99], N[(N[(i * k), $MachinePrecision] * N[(y * y5 + N[((-y1) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.6e+67], N[((-i) * N[(j * N[((-x) * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.8 \cdot 10^{+180}:\\
\;\;\;\;\left(b \cdot j\right) \cdot \left(\left(-x\right) \cdot y0\right)\\
\mathbf{elif}\;b \leq 1.48 \cdot 10^{-99}:\\
\;\;\;\;\left(i \cdot k\right) \cdot \mathsf{fma}\left(y, y5, \left(-y1\right) \cdot z\right)\\
\mathbf{elif}\;b \leq 9.6 \cdot 10^{+67}:\\
\;\;\;\;\left(-i\right) \cdot \left(j \cdot \left(\left(-x\right) \cdot y1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\end{array}
\end{array}
if b < -3.8e180Initial program 27.3%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.3%
Taylor expanded in t around inf
Applied rewrites34.1%
Taylor expanded in j around inf
Applied rewrites49.3%
Taylor expanded in x around inf
Applied rewrites40.2%
if -3.8e180 < b < 1.48000000000000007e-99Initial program 36.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.8%
Taylor expanded in k around -inf
Applied rewrites31.1%
if 1.48000000000000007e-99 < b < 9.60000000000000007e67Initial program 28.9%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites47.8%
Taylor expanded in j around inf
Applied rewrites48.3%
Taylor expanded in x around inf
Applied rewrites37.8%
if 9.60000000000000007e67 < b Initial program 21.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites66.1%
Taylor expanded in t around inf
Applied rewrites49.8%
Taylor expanded in j around inf
Applied rewrites56.6%
Taylor expanded in x around 0
Applied rewrites43.5%
Final simplification35.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= c -3.6e+26)
(* (* c y2) (fma x y0 (* (- t) y4)))
(if (<= c 6.2e+106)
(* (* i y1) (fma j x (* (- k) z)))
(* (* c y0) (fma x y2 (* (- y3) z))))))
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 (c <= -3.6e+26) {
tmp = (c * y2) * fma(x, y0, (-t * y4));
} else if (c <= 6.2e+106) {
tmp = (i * y1) * fma(j, x, (-k * z));
} else {
tmp = (c * y0) * fma(x, y2, (-y3 * z));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (c <= -3.6e+26) tmp = Float64(Float64(c * y2) * fma(x, y0, Float64(Float64(-t) * y4))); elseif (c <= 6.2e+106) tmp = Float64(Float64(i * y1) * fma(j, x, Float64(Float64(-k) * z))); else tmp = Float64(Float64(c * y0) * fma(x, y2, Float64(Float64(-y3) * z))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[c, -3.6e+26], N[(N[(c * y2), $MachinePrecision] * N[(x * y0 + N[((-t) * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.2e+106], N[(N[(i * y1), $MachinePrecision] * N[(j * x + N[((-k) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(c * y0), $MachinePrecision] * N[(x * y2 + N[((-y3) * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.6 \cdot 10^{+26}:\\
\;\;\;\;\left(c \cdot y2\right) \cdot \mathsf{fma}\left(x, y0, \left(-t\right) \cdot y4\right)\\
\mathbf{elif}\;c \leq 6.2 \cdot 10^{+106}:\\
\;\;\;\;\left(i \cdot y1\right) \cdot \mathsf{fma}\left(j, x, \left(-k\right) \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;\left(c \cdot y0\right) \cdot \mathsf{fma}\left(x, y2, \left(-y3\right) \cdot z\right)\\
\end{array}
\end{array}
if c < -3.60000000000000024e26Initial program 34.0%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites47.0%
Taylor expanded in y2 around inf
Applied rewrites54.7%
if -3.60000000000000024e26 < c < 6.1999999999999999e106Initial program 34.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.9%
Taylor expanded in k around -inf
Applied rewrites28.6%
Taylor expanded in y1 around inf
Applied rewrites32.8%
if 6.1999999999999999e106 < c Initial program 13.2%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites58.1%
Taylor expanded in t around inf
Applied rewrites35.4%
Taylor expanded in y0 around inf
Applied rewrites49.3%
Final simplification39.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* b j) (* t y4))))
(if (<= b -6e+78)
t_1
(if (<= b 6.8e-305)
(* i (* (* y5 k) y))
(if (<= b 4.9e+76) (* (* i (* t z)) c) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (b * j) * (t * y4);
double tmp;
if (b <= -6e+78) {
tmp = t_1;
} else if (b <= 6.8e-305) {
tmp = i * ((y5 * k) * y);
} else if (b <= 4.9e+76) {
tmp = (i * (t * z)) * c;
} 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 = (b * j) * (t * y4)
if (b <= (-6d+78)) then
tmp = t_1
else if (b <= 6.8d-305) then
tmp = i * ((y5 * k) * y)
else if (b <= 4.9d+76) then
tmp = (i * (t * z)) * c
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 = (b * j) * (t * y4);
double tmp;
if (b <= -6e+78) {
tmp = t_1;
} else if (b <= 6.8e-305) {
tmp = i * ((y5 * k) * y);
} else if (b <= 4.9e+76) {
tmp = (i * (t * z)) * c;
} 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 = (b * j) * (t * y4) tmp = 0 if b <= -6e+78: tmp = t_1 elif b <= 6.8e-305: tmp = i * ((y5 * k) * y) elif b <= 4.9e+76: tmp = (i * (t * z)) * c 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(b * j) * Float64(t * y4)) tmp = 0.0 if (b <= -6e+78) tmp = t_1; elseif (b <= 6.8e-305) tmp = Float64(i * Float64(Float64(y5 * k) * y)); elseif (b <= 4.9e+76) tmp = Float64(Float64(i * Float64(t * z)) * c); 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 = (b * j) * (t * y4); tmp = 0.0; if (b <= -6e+78) tmp = t_1; elseif (b <= 6.8e-305) tmp = i * ((y5 * k) * y); elseif (b <= 4.9e+76) tmp = (i * (t * z)) * c; 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[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6e+78], t$95$1, If[LessEqual[b, 6.8e-305], N[(i * N[(N[(y5 * k), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.9e+76], N[(N[(i * N[(t * z), $MachinePrecision]), $MachinePrecision] * c), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\mathbf{if}\;b \leq -6 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 6.8 \cdot 10^{-305}:\\
\;\;\;\;i \cdot \left(\left(y5 \cdot k\right) \cdot y\right)\\
\mathbf{elif}\;b \leq 4.9 \cdot 10^{+76}:\\
\;\;\;\;\left(i \cdot \left(t \cdot z\right)\right) \cdot c\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.99999999999999964e78 or 4.90000000000000026e76 < b Initial program 24.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites60.4%
Taylor expanded in t around inf
Applied rewrites48.2%
Taylor expanded in j around inf
Applied rewrites53.7%
Taylor expanded in x around 0
Applied rewrites39.9%
if -5.99999999999999964e78 < b < 6.8000000000000001e-305Initial program 37.4%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites38.1%
Taylor expanded in k around -inf
Applied rewrites32.2%
Taylor expanded in y around inf
Applied rewrites28.7%
Applied rewrites31.1%
if 6.8000000000000001e-305 < b < 4.90000000000000026e76Initial program 33.8%
Taylor expanded in c around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.9%
Taylor expanded in t around inf
Applied rewrites34.9%
Taylor expanded in z around inf
Applied rewrites28.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (or (<= k -1.12e+15) (not (<= k 8.1e+21))) (* i (* (* k y) y5)) (* (* b j) (* t 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 ((k <= -1.12e+15) || !(k <= 8.1e+21)) {
tmp = i * ((k * y) * y5);
} else {
tmp = (b * j) * (t * y4);
}
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 ((k <= (-1.12d+15)) .or. (.not. (k <= 8.1d+21))) then
tmp = i * ((k * y) * y5)
else
tmp = (b * j) * (t * y4)
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 ((k <= -1.12e+15) || !(k <= 8.1e+21)) {
tmp = i * ((k * y) * y5);
} else {
tmp = (b * j) * (t * y4);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if (k <= -1.12e+15) or not (k <= 8.1e+21): tmp = i * ((k * y) * y5) else: tmp = (b * j) * (t * 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 ((k <= -1.12e+15) || !(k <= 8.1e+21)) tmp = Float64(i * Float64(Float64(k * y) * y5)); else tmp = Float64(Float64(b * j) * Float64(t * y4)); 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 ((k <= -1.12e+15) || ~((k <= 8.1e+21))) tmp = i * ((k * y) * y5); else tmp = (b * j) * (t * y4); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[Or[LessEqual[k, -1.12e+15], N[Not[LessEqual[k, 8.1e+21]], $MachinePrecision]], N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision], N[(N[(b * j), $MachinePrecision] * N[(t * y4), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -1.12 \cdot 10^{+15} \lor \neg \left(k \leq 8.1 \cdot 10^{+21}\right):\\
\;\;\;\;i \cdot \left(\left(k \cdot y\right) \cdot y5\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot j\right) \cdot \left(t \cdot y4\right)\\
\end{array}
\end{array}
if k < -1.12e15 or 8.1e21 < k Initial program 24.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.1%
Taylor expanded in k around -inf
Applied rewrites37.9%
Taylor expanded in y around inf
Applied rewrites35.6%
if -1.12e15 < k < 8.1e21Initial program 37.5%
Taylor expanded in b around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites41.9%
Taylor expanded in t around inf
Applied rewrites30.4%
Taylor expanded in j around inf
Applied rewrites36.8%
Taylor expanded in x around 0
Applied rewrites24.8%
Final simplification29.8%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (<= b -6e-188) (* i (* (* y5 k) y)) (* (* (* i k) y) y5)))
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 (b <= -6e-188) {
tmp = i * ((y5 * k) * y);
} else {
tmp = ((i * k) * y) * y5;
}
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 (b <= (-6d-188)) then
tmp = i * ((y5 * k) * y)
else
tmp = ((i * k) * y) * y5
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 (b <= -6e-188) {
tmp = i * ((y5 * k) * y);
} else {
tmp = ((i * k) * y) * y5;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if b <= -6e-188: tmp = i * ((y5 * k) * y) else: tmp = ((i * k) * y) * y5 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (b <= -6e-188) tmp = Float64(i * Float64(Float64(y5 * k) * y)); else tmp = Float64(Float64(Float64(i * k) * y) * y5); 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 (b <= -6e-188) tmp = i * ((y5 * k) * y); else tmp = ((i * k) * y) * y5; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[b, -6e-188], N[(i * N[(N[(y5 * k), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision], N[(N[(N[(i * k), $MachinePrecision] * y), $MachinePrecision] * y5), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6 \cdot 10^{-188}:\\
\;\;\;\;i \cdot \left(\left(y5 \cdot k\right) \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(i \cdot k\right) \cdot y\right) \cdot y5\\
\end{array}
\end{array}
if b < -6.00000000000000033e-188Initial program 32.6%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites38.3%
Taylor expanded in k around -inf
Applied rewrites23.7%
Taylor expanded in y around inf
Applied rewrites23.7%
Applied rewrites24.7%
if -6.00000000000000033e-188 < b Initial program 30.8%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites33.3%
Taylor expanded in k around -inf
Applied rewrites22.8%
Taylor expanded in y around inf
Applied rewrites16.7%
Applied rewrites19.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (* i (* (* k y) y5)))
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 i * ((k * y) * y5);
}
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 = i * ((k * y) * y5)
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 i * ((k * y) * y5);
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return i * ((k * y) * y5)
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(i * Float64(Float64(k * y) * y5)) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = i * ((k * y) * y5); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(i * N[(N[(k * y), $MachinePrecision] * y5), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
i \cdot \left(\left(k \cdot y\right) \cdot y5\right)
\end{array}
Initial program 31.5%
Taylor expanded in i around -inf
mul-1-negN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower--.f64N/A
Applied rewrites35.2%
Taylor expanded in k around -inf
Applied rewrites23.2%
Taylor expanded in y around inf
Applied rewrites19.4%
(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 2024320
(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)))))