
(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 28 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 (- (* x j) (* z k)))
(t_2
(+
(+
(+
(-
(* (- (* c y0) (* a y1)) (- (* x y2) (* z y3)))
(+
(* (- (* b y0) (* i y1)) t_1)
(* (- (* a b) (* c i)) (- (* z t) (* x y)))))
(* (- (* b y4) (* i y5)) (- (* t j) (* y k))))
(* (- (* t y2) (* y y3)) (- (* a y5) (* c y4))))
(* (- (* k y2) (* j y3)) (- (* y1 y4) (* y0 y5))))))
(if (<= t_2 INFINITY)
t_2
(*
y1
(fma
a
(- (* z y3) (* x y2))
(fma y4 (fma k y2 (* j (- y3))) (* i 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 = (x * j) - (z * k);
double t_2 = ((((((c * y0) - (a * y1)) * ((x * y2) - (z * y3))) - ((((b * y0) - (i * y1)) * t_1) + (((a * b) - (c * i)) * ((z * t) - (x * y))))) + (((b * y4) - (i * y5)) * ((t * j) - (y * k)))) + (((t * y2) - (y * y3)) * ((a * y5) - (c * y4)))) + (((k * y2) - (j * y3)) * ((y1 * y4) - (y0 * y5)));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = y1 * fma(a, ((z * y3) - (x * y2)), fma(y4, fma(k, y2, (j * -y3)), (i * 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(x * j) - Float64(z * k)) t_2 = Float64(Float64(Float64(Float64(Float64(Float64(Float64(c * y0) - Float64(a * y1)) * Float64(Float64(x * y2) - Float64(z * y3))) - Float64(Float64(Float64(Float64(b * y0) - Float64(i * y1)) * t_1) + Float64(Float64(Float64(a * b) - Float64(c * i)) * Float64(Float64(z * t) - Float64(x * y))))) + Float64(Float64(Float64(b * y4) - Float64(i * y5)) * Float64(Float64(t * j) - Float64(y * k)))) + Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(Float64(a * y5) - Float64(c * y4)))) + Float64(Float64(Float64(k * y2) - Float64(j * y3)) * Float64(Float64(y1 * y4) - Float64(y0 * y5)))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; else tmp = Float64(y1 * fma(a, Float64(Float64(z * y3) - Float64(x * y2)), fma(y4, fma(k, y2, Float64(j * Float64(-y3))), Float64(i * 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[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[(N[(N[(c * y0), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision] * N[(N[(x * y2), $MachinePrecision] - N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(N[(b * y0), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision] + N[(N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision] * N[(N[(z * t), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(b * y4), $MachinePrecision] - N[(i * y5), $MachinePrecision]), $MachinePrecision] * N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(a * y5), $MachinePrecision] - N[(c * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(k * y2), $MachinePrecision] - N[(j * y3), $MachinePrecision]), $MachinePrecision] * N[(N[(y1 * y4), $MachinePrecision] - N[(y0 * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision] + N[(y4 * N[(k * y2 + N[(j * (-y3)), $MachinePrecision]), $MachinePrecision] + N[(i * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot j - z \cdot k\\
t_2 := \left(\left(\left(\left(c \cdot y0 - a \cdot y1\right) \cdot \left(x \cdot y2 - z \cdot y3\right) - \left(\left(b \cdot y0 - i \cdot y1\right) \cdot t\_1 + \left(a \cdot b - c \cdot i\right) \cdot \left(z \cdot t - x \cdot y\right)\right)\right) + \left(b \cdot y4 - i \cdot y5\right) \cdot \left(t \cdot j - y \cdot k\right)\right) + \left(t \cdot y2 - y \cdot y3\right) \cdot \left(a \cdot y5 - c \cdot y4\right)\right) + \left(k \cdot y2 - j \cdot y3\right) \cdot \left(y1 \cdot y4 - y0 \cdot y5\right)\\
\mathbf{if}\;t\_2 \leq \infty:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;y1 \cdot \mathsf{fma}\left(a, z \cdot y3 - x \cdot y2, \mathsf{fma}\left(y4, \mathsf{fma}\left(k, y2, j \cdot \left(-y3\right)\right), i \cdot t\_1\right)\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 93.6%
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 y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites46.3%
Final simplification60.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* b y4) (* i y5)))
(t_2
(*
y1
(fma
a
(- (* z y3) (* x y2))
(fma y4 (fma k y2 (* j (- y3))) (* i (- (* x j) (* z k))))))))
(if (<= y1 -7e+33)
t_2
(if (<= y1 -4.5e-44)
(*
y
(fma
t_1
(- k)
(fma (- (* a b) (* c i)) x (* y3 (- (* c y4) (* a y5))))))
(if (<= y1 2.2e-150)
(*
k
(fma
t_1
(- y)
(fma y2 (- (* y1 y4) (* y0 y5)) (* z (- (* b y0) (* i y1))))))
(if (<= y1 27500000000.0)
(*
b
(+
(fma a (- (* x y) (* z t)) (* y4 (- (* t j) (* y k))))
(* y0 (- (* z k) (* x j)))))
t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (b * y4) - (i * y5);
double t_2 = y1 * fma(a, ((z * y3) - (x * y2)), fma(y4, fma(k, y2, (j * -y3)), (i * ((x * j) - (z * k)))));
double tmp;
if (y1 <= -7e+33) {
tmp = t_2;
} else if (y1 <= -4.5e-44) {
tmp = y * fma(t_1, -k, fma(((a * b) - (c * i)), x, (y3 * ((c * y4) - (a * y5)))));
} else if (y1 <= 2.2e-150) {
tmp = k * fma(t_1, -y, fma(y2, ((y1 * y4) - (y0 * y5)), (z * ((b * y0) - (i * y1)))));
} else if (y1 <= 27500000000.0) {
tmp = b * (fma(a, ((x * y) - (z * t)), (y4 * ((t * j) - (y * k)))) + (y0 * ((z * k) - (x * j))));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(b * y4) - Float64(i * y5)) t_2 = Float64(y1 * fma(a, Float64(Float64(z * y3) - Float64(x * y2)), fma(y4, fma(k, y2, Float64(j * Float64(-y3))), Float64(i * Float64(Float64(x * j) - Float64(z * k)))))) tmp = 0.0 if (y1 <= -7e+33) tmp = t_2; elseif (y1 <= -4.5e-44) tmp = Float64(y * fma(t_1, Float64(-k), fma(Float64(Float64(a * b) - Float64(c * i)), x, Float64(y3 * Float64(Float64(c * y4) - Float64(a * y5)))))); elseif (y1 <= 2.2e-150) tmp = Float64(k * fma(t_1, Float64(-y), fma(y2, Float64(Float64(y1 * y4) - Float64(y0 * y5)), Float64(z * Float64(Float64(b * y0) - Float64(i * y1)))))); elseif (y1 <= 27500000000.0) tmp = Float64(b * Float64(fma(a, Float64(Float64(x * y) - Float64(z * t)), Float64(y4 * Float64(Float64(t * j) - Float64(y * k)))) + Float64(y0 * Float64(Float64(z * k) - Float64(x * j))))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(b * y4), $MachinePrecision] - N[(i * y5), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision] + N[(y4 * N[(k * y2 + N[(j * (-y3)), $MachinePrecision]), $MachinePrecision] + N[(i * N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y1, -7e+33], t$95$2, If[LessEqual[y1, -4.5e-44], N[(y * N[(t$95$1 * (-k) + N[(N[(N[(a * b), $MachinePrecision] - N[(c * i), $MachinePrecision]), $MachinePrecision] * x + N[(y3 * N[(N[(c * y4), $MachinePrecision] - N[(a * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 2.2e-150], N[(k * N[(t$95$1 * (-y) + N[(y2 * N[(N[(y1 * y4), $MachinePrecision] - N[(y0 * y5), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(b * y0), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 27500000000.0], N[(b * N[(N[(a * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] + N[(y4 * N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(N[(z * k), $MachinePrecision] - N[(x * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot y4 - i \cdot y5\\
t_2 := y1 \cdot \mathsf{fma}\left(a, z \cdot y3 - x \cdot y2, \mathsf{fma}\left(y4, \mathsf{fma}\left(k, y2, j \cdot \left(-y3\right)\right), i \cdot \left(x \cdot j - z \cdot k\right)\right)\right)\\
\mathbf{if}\;y1 \leq -7 \cdot 10^{+33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y1 \leq -4.5 \cdot 10^{-44}:\\
\;\;\;\;y \cdot \mathsf{fma}\left(t\_1, -k, \mathsf{fma}\left(a \cdot b - c \cdot i, x, y3 \cdot \left(c \cdot y4 - a \cdot y5\right)\right)\right)\\
\mathbf{elif}\;y1 \leq 2.2 \cdot 10^{-150}:\\
\;\;\;\;k \cdot \mathsf{fma}\left(t\_1, -y, \mathsf{fma}\left(y2, y1 \cdot y4 - y0 \cdot y5, z \cdot \left(b \cdot y0 - i \cdot y1\right)\right)\right)\\
\mathbf{elif}\;y1 \leq 27500000000:\\
\;\;\;\;b \cdot \left(\mathsf{fma}\left(a, x \cdot y - z \cdot t, y4 \cdot \left(t \cdot j - y \cdot k\right)\right) + y0 \cdot \left(z \cdot k - x \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y1 < -7.0000000000000002e33 or 2.75e10 < y1 Initial program 22.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites61.8%
if -7.0000000000000002e33 < y1 < -4.4999999999999999e-44Initial program 50.0%
Taylor expanded in y around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
sub-negN/A
Applied rewrites80.4%
if -4.4999999999999999e-44 < y1 < 2.1999999999999999e-150Initial program 32.4%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites48.8%
if 2.1999999999999999e-150 < y1 < 2.75e10Initial program 22.7%
Taylor expanded in b around inf
lower-*.f64N/A
lower--.f64N/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6468.0
Applied rewrites68.0%
Final simplification58.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (- (* x y) (* z t)))
(t_2
(*
k
(fma
(- (* b y4) (* i y5))
(- y)
(fma y2 (- (* y1 y4) (* y0 y5)) (* z (- (* b y0) (* i y1))))))))
(if (<= k -1000000.0)
t_2
(if (<= k -2.15e-274)
(*
b
(+ (fma a t_1 (* y4 (- (* t j) (* y k)))) (* y0 (- (* z k) (* x j)))))
(if (<= k 7.5e+96)
(*
a
(fma
y1
(- (* z y3) (* x y2))
(fma b t_1 (* y5 (- (* t y2) (* y y3))))))
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 = (x * y) - (z * t);
double t_2 = k * fma(((b * y4) - (i * y5)), -y, fma(y2, ((y1 * y4) - (y0 * y5)), (z * ((b * y0) - (i * y1)))));
double tmp;
if (k <= -1000000.0) {
tmp = t_2;
} else if (k <= -2.15e-274) {
tmp = b * (fma(a, t_1, (y4 * ((t * j) - (y * k)))) + (y0 * ((z * k) - (x * j))));
} else if (k <= 7.5e+96) {
tmp = a * fma(y1, ((z * y3) - (x * y2)), fma(b, t_1, (y5 * ((t * y2) - (y * y3)))));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(x * y) - Float64(z * t)) t_2 = Float64(k * fma(Float64(Float64(b * y4) - Float64(i * y5)), Float64(-y), fma(y2, Float64(Float64(y1 * y4) - Float64(y0 * y5)), Float64(z * Float64(Float64(b * y0) - Float64(i * y1)))))) tmp = 0.0 if (k <= -1000000.0) tmp = t_2; elseif (k <= -2.15e-274) tmp = Float64(b * Float64(fma(a, t_1, Float64(y4 * Float64(Float64(t * j) - Float64(y * k)))) + Float64(y0 * Float64(Float64(z * k) - Float64(x * j))))); elseif (k <= 7.5e+96) tmp = Float64(a * fma(y1, Float64(Float64(z * y3) - Float64(x * y2)), fma(b, t_1, Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(k * N[(N[(N[(b * y4), $MachinePrecision] - N[(i * y5), $MachinePrecision]), $MachinePrecision] * (-y) + N[(y2 * N[(N[(y1 * y4), $MachinePrecision] - N[(y0 * y5), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(b * y0), $MachinePrecision] - N[(i * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -1000000.0], t$95$2, If[LessEqual[k, -2.15e-274], N[(b * N[(N[(a * t$95$1 + N[(y4 * N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(y0 * N[(N[(z * k), $MachinePrecision] - N[(x * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 7.5e+96], N[(a * N[(y1 * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision] + N[(b * t$95$1 + N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot y - z \cdot t\\
t_2 := k \cdot \mathsf{fma}\left(b \cdot y4 - i \cdot y5, -y, \mathsf{fma}\left(y2, y1 \cdot y4 - y0 \cdot y5, z \cdot \left(b \cdot y0 - i \cdot y1\right)\right)\right)\\
\mathbf{if}\;k \leq -1000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;k \leq -2.15 \cdot 10^{-274}:\\
\;\;\;\;b \cdot \left(\mathsf{fma}\left(a, t\_1, y4 \cdot \left(t \cdot j - y \cdot k\right)\right) + y0 \cdot \left(z \cdot k - x \cdot j\right)\right)\\
\mathbf{elif}\;k \leq 7.5 \cdot 10^{+96}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(y1, z \cdot y3 - x \cdot y2, \mathsf{fma}\left(b, t\_1, y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if k < -1e6 or 7.4999999999999996e96 < k Initial program 26.5%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites60.7%
if -1e6 < k < -2.14999999999999995e-274Initial program 27.6%
Taylor expanded in b around inf
lower-*.f64N/A
lower--.f64N/A
lower-fma.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6453.5
Applied rewrites53.5%
if -2.14999999999999995e-274 < k < 7.4999999999999996e96Initial program 27.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites51.6%
Final simplification56.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1
(*
y2
(fma
k
(- (* y1 y4) (* y0 y5))
(fma (- (* c y0) (* a y1)) x (* t (- (* a y5) (* c y4)))))))
(t_2 (- (* z y3) (* x y2))))
(if (<= y2 -4e+183)
t_1
(if (<= y2 -1.42e-278)
(*
y1
(fma a t_2 (fma y4 (fma k y2 (* j (- y3))) (* i (- (* x j) (* z k))))))
(if (<= y2 1.55e+115)
(*
a
(fma
y1
t_2
(fma b (- (* x y) (* z t)) (* y5 (- (* t y2) (* y y3))))))
t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = y2 * fma(k, ((y1 * y4) - (y0 * y5)), fma(((c * y0) - (a * y1)), x, (t * ((a * y5) - (c * y4)))));
double t_2 = (z * y3) - (x * y2);
double tmp;
if (y2 <= -4e+183) {
tmp = t_1;
} else if (y2 <= -1.42e-278) {
tmp = y1 * fma(a, t_2, fma(y4, fma(k, y2, (j * -y3)), (i * ((x * j) - (z * k)))));
} else if (y2 <= 1.55e+115) {
tmp = a * fma(y1, t_2, fma(b, ((x * y) - (z * t)), (y5 * ((t * y2) - (y * y3)))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(y2 * fma(k, Float64(Float64(y1 * y4) - Float64(y0 * y5)), fma(Float64(Float64(c * y0) - Float64(a * y1)), x, Float64(t * Float64(Float64(a * y5) - Float64(c * y4)))))) t_2 = Float64(Float64(z * y3) - Float64(x * y2)) tmp = 0.0 if (y2 <= -4e+183) tmp = t_1; elseif (y2 <= -1.42e-278) tmp = Float64(y1 * fma(a, t_2, fma(y4, fma(k, y2, Float64(j * Float64(-y3))), Float64(i * Float64(Float64(x * j) - Float64(z * k)))))); elseif (y2 <= 1.55e+115) tmp = Float64(a * fma(y1, t_2, fma(b, Float64(Float64(x * y) - Float64(z * t)), Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(y2 * N[(k * N[(N[(y1 * y4), $MachinePrecision] - N[(y0 * y5), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(c * y0), $MachinePrecision] - N[(a * y1), $MachinePrecision]), $MachinePrecision] * x + N[(t * N[(N[(a * y5), $MachinePrecision] - N[(c * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y2, -4e+183], t$95$1, If[LessEqual[y2, -1.42e-278], N[(y1 * N[(a * t$95$2 + N[(y4 * N[(k * y2 + N[(j * (-y3)), $MachinePrecision]), $MachinePrecision] + N[(i * N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y2, 1.55e+115], N[(a * N[(y1 * t$95$2 + N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] + N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y2 \cdot \mathsf{fma}\left(k, y1 \cdot y4 - y0 \cdot y5, \mathsf{fma}\left(c \cdot y0 - a \cdot y1, x, t \cdot \left(a \cdot y5 - c \cdot y4\right)\right)\right)\\
t_2 := z \cdot y3 - x \cdot y2\\
\mathbf{if}\;y2 \leq -4 \cdot 10^{+183}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y2 \leq -1.42 \cdot 10^{-278}:\\
\;\;\;\;y1 \cdot \mathsf{fma}\left(a, t\_2, \mathsf{fma}\left(y4, \mathsf{fma}\left(k, y2, j \cdot \left(-y3\right)\right), i \cdot \left(x \cdot j - z \cdot k\right)\right)\right)\\
\mathbf{elif}\;y2 \leq 1.55 \cdot 10^{+115}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(y1, t\_2, \mathsf{fma}\left(b, x \cdot y - z \cdot t, y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y2 < -3.99999999999999979e183 or 1.55000000000000002e115 < y2 Initial program 17.6%
Taylor expanded in y2 around inf
lower-*.f64N/A
associate--l+N/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
*-commutativeN/A
mul-1-negN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
Applied rewrites64.0%
if -3.99999999999999979e183 < y2 < -1.41999999999999987e-278Initial program 27.4%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites51.8%
if -1.41999999999999987e-278 < y2 < 1.55000000000000002e115Initial program 35.0%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites60.2%
Final simplification58.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* y1 (* a (- (* z y3) (* x y2)))))
(t_2 (* (* k y1) (fma y2 y4 (* z (- i))))))
(if (<= a -5.4e+72)
t_1
(if (<= a -7e-86)
(* y4 (* b (- (* t j) (* y k))))
(if (<= a -9.5e-209)
(* (* k y0) (fma b z (* y2 (- y5))))
(if (<= a 3.8e-293)
t_2
(if (<= a 3.6e-222)
(* (* x y0) (- (* c y2) (* b j)))
(if (<= a 1.55e-126)
(* y4 (* y3 (- (* y c) (* j y1))))
(if (<= a 3.45)
(* (* z c) (fma t i (* y0 (- y3))))
(if (<= a 5e+63)
t_2
(if (<= a 1e+279)
t_1
(* y2 (* y5 (- (* t a) (* k 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) {
double t_1 = y1 * (a * ((z * y3) - (x * y2)));
double t_2 = (k * y1) * fma(y2, y4, (z * -i));
double tmp;
if (a <= -5.4e+72) {
tmp = t_1;
} else if (a <= -7e-86) {
tmp = y4 * (b * ((t * j) - (y * k)));
} else if (a <= -9.5e-209) {
tmp = (k * y0) * fma(b, z, (y2 * -y5));
} else if (a <= 3.8e-293) {
tmp = t_2;
} else if (a <= 3.6e-222) {
tmp = (x * y0) * ((c * y2) - (b * j));
} else if (a <= 1.55e-126) {
tmp = y4 * (y3 * ((y * c) - (j * y1)));
} else if (a <= 3.45) {
tmp = (z * c) * fma(t, i, (y0 * -y3));
} else if (a <= 5e+63) {
tmp = t_2;
} else if (a <= 1e+279) {
tmp = t_1;
} else {
tmp = y2 * (y5 * ((t * a) - (k * y0)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(y1 * Float64(a * Float64(Float64(z * y3) - Float64(x * y2)))) t_2 = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))) tmp = 0.0 if (a <= -5.4e+72) tmp = t_1; elseif (a <= -7e-86) tmp = Float64(y4 * Float64(b * Float64(Float64(t * j) - Float64(y * k)))); elseif (a <= -9.5e-209) tmp = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))); elseif (a <= 3.8e-293) tmp = t_2; elseif (a <= 3.6e-222) tmp = Float64(Float64(x * y0) * Float64(Float64(c * y2) - Float64(b * j))); elseif (a <= 1.55e-126) tmp = Float64(y4 * Float64(y3 * Float64(Float64(y * c) - Float64(j * y1)))); elseif (a <= 3.45) tmp = Float64(Float64(z * c) * fma(t, i, Float64(y0 * Float64(-y3)))); elseif (a <= 5e+63) tmp = t_2; elseif (a <= 1e+279) tmp = t_1; else tmp = Float64(y2 * Float64(y5 * Float64(Float64(t * a) - Float64(k * y0)))); 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[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.4e+72], t$95$1, If[LessEqual[a, -7e-86], N[(y4 * N[(b * N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -9.5e-209], N[(N[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.8e-293], t$95$2, If[LessEqual[a, 3.6e-222], N[(N[(x * y0), $MachinePrecision] * N[(N[(c * y2), $MachinePrecision] - N[(b * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 1.55e-126], N[(y4 * N[(y3 * N[(N[(y * c), $MachinePrecision] - N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.45], N[(N[(z * c), $MachinePrecision] * N[(t * i + N[(y0 * (-y3)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e+63], t$95$2, If[LessEqual[a, 1e+279], t$95$1, N[(y2 * N[(y5 * N[(N[(t * a), $MachinePrecision] - N[(k * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y1 \cdot \left(a \cdot \left(z \cdot y3 - x \cdot y2\right)\right)\\
t_2 := \left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{if}\;a \leq -5.4 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -7 \cdot 10^{-86}:\\
\;\;\;\;y4 \cdot \left(b \cdot \left(t \cdot j - y \cdot k\right)\right)\\
\mathbf{elif}\;a \leq -9.5 \cdot 10^{-209}:\\
\;\;\;\;\left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{elif}\;a \leq 3.8 \cdot 10^{-293}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{-222}:\\
\;\;\;\;\left(x \cdot y0\right) \cdot \left(c \cdot y2 - b \cdot j\right)\\
\mathbf{elif}\;a \leq 1.55 \cdot 10^{-126}:\\
\;\;\;\;y4 \cdot \left(y3 \cdot \left(y \cdot c - j \cdot y1\right)\right)\\
\mathbf{elif}\;a \leq 3.45:\\
\;\;\;\;\left(z \cdot c\right) \cdot \mathsf{fma}\left(t, i, y0 \cdot \left(-y3\right)\right)\\
\mathbf{elif}\;a \leq 5 \cdot 10^{+63}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 10^{+279}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y2 \cdot \left(y5 \cdot \left(t \cdot a - k \cdot y0\right)\right)\\
\end{array}
\end{array}
if a < -5.4000000000000001e72 or 5.00000000000000011e63 < a < 1.00000000000000006e279Initial program 20.4%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites54.4%
Taylor expanded in a around inf
Applied rewrites60.1%
if -5.4000000000000001e72 < a < -7.00000000000000041e-86Initial program 22.9%
Taylor expanded in y4 around inf
lower-*.f64N/A
lower--.f64N/A
Applied rewrites39.5%
Taylor expanded in b around inf
Applied rewrites52.5%
if -7.00000000000000041e-86 < a < -9.50000000000000028e-209Initial program 18.5%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites50.2%
Taylor expanded in y0 around inf
Applied rewrites50.7%
if -9.50000000000000028e-209 < a < 3.8e-293 or 3.4500000000000002 < a < 5.00000000000000011e63Initial program 31.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites50.7%
Taylor expanded in i around inf
Applied rewrites35.5%
Taylor expanded in j around 0
Applied rewrites27.9%
Taylor expanded in k around inf
Applied rewrites58.9%
if 3.8e-293 < a < 3.59999999999999974e-222Initial program 43.7%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6432.6
Applied rewrites32.6%
Taylor expanded in y0 around inf
Applied rewrites57.8%
if 3.59999999999999974e-222 < a < 1.5500000000000001e-126Initial program 49.8%
Taylor expanded in y4 around inf
lower-*.f64N/A
lower--.f64N/A
Applied rewrites56.1%
Taylor expanded in y3 around -inf
Applied rewrites56.2%
if 1.5500000000000001e-126 < a < 3.4500000000000002Initial program 29.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites45.5%
Taylor expanded in z around -inf
Applied rewrites49.1%
if 1.00000000000000006e279 < a Initial program 27.3%
Taylor expanded in y5 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites63.6%
Taylor expanded in y2 around -inf
Applied rewrites81.8%
Final simplification57.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= k -6.6e+237)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= k 2.1e+93)
(*
a
(fma
y1
(- (* z y3) (* x y2))
(fma b (- (* x y) (* z t)) (* y5 (- (* t y2) (* y y3))))))
(* k (* i (fma y y5 (* z (- y1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (k <= -6.6e+237) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (k <= 2.1e+93) {
tmp = a * fma(y1, ((z * y3) - (x * y2)), fma(b, ((x * y) - (z * t)), (y5 * ((t * y2) - (y * y3)))));
} else {
tmp = k * (i * fma(y, y5, (z * -y1)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (k <= -6.6e+237) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (k <= 2.1e+93) tmp = Float64(a * fma(y1, Float64(Float64(z * y3) - Float64(x * y2)), fma(b, Float64(Float64(x * y) - Float64(z * t)), Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))))); else tmp = Float64(k * Float64(i * fma(y, y5, Float64(z * Float64(-y1))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[k, -6.6e+237], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.1e+93], N[(a * N[(y1 * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision] + N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(k * N[(i * N[(y * y5 + N[(z * (-y1)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq -6.6 \cdot 10^{+237}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;k \leq 2.1 \cdot 10^{+93}:\\
\;\;\;\;a \cdot \mathsf{fma}\left(y1, z \cdot y3 - x \cdot y2, \mathsf{fma}\left(b, x \cdot y - z \cdot t, y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;k \cdot \left(i \cdot \mathsf{fma}\left(y, y5, z \cdot \left(-y1\right)\right)\right)\\
\end{array}
\end{array}
if k < -6.6000000000000001e237Initial program 15.8%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites63.2%
Taylor expanded in y5 around inf
Applied rewrites79.4%
if -6.6000000000000001e237 < k < 2.0999999999999998e93Initial program 26.7%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites48.3%
if 2.0999999999999998e93 < k Initial program 32.2%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites66.4%
Taylor expanded in i around inf
Applied rewrites48.7%
Final simplification50.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* y1 (* a (- (* z y3) (* x y2)))))
(t_2 (* (* k y1) (fma y2 y4 (* z (- i))))))
(if (<= a -5.4e+72)
t_1
(if (<= a -7e-86)
(* y4 (* b (- (* t j) (* y k))))
(if (<= a -9.5e-209)
(* (* k y0) (fma b z (* y2 (- y5))))
(if (<= a 4.95e-293)
t_2
(if (<= a 6.6e-153)
(* (* c y2) (fma (- t) y4 (* x y0)))
(if (<= a 3.45)
(* (* z c) (fma t i (* y0 (- y3))))
(if (<= a 5e+63)
t_2
(if (<= a 1e+279)
t_1
(* y2 (* y5 (- (* t a) (* k 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) {
double t_1 = y1 * (a * ((z * y3) - (x * y2)));
double t_2 = (k * y1) * fma(y2, y4, (z * -i));
double tmp;
if (a <= -5.4e+72) {
tmp = t_1;
} else if (a <= -7e-86) {
tmp = y4 * (b * ((t * j) - (y * k)));
} else if (a <= -9.5e-209) {
tmp = (k * y0) * fma(b, z, (y2 * -y5));
} else if (a <= 4.95e-293) {
tmp = t_2;
} else if (a <= 6.6e-153) {
tmp = (c * y2) * fma(-t, y4, (x * y0));
} else if (a <= 3.45) {
tmp = (z * c) * fma(t, i, (y0 * -y3));
} else if (a <= 5e+63) {
tmp = t_2;
} else if (a <= 1e+279) {
tmp = t_1;
} else {
tmp = y2 * (y5 * ((t * a) - (k * y0)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(y1 * Float64(a * Float64(Float64(z * y3) - Float64(x * y2)))) t_2 = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))) tmp = 0.0 if (a <= -5.4e+72) tmp = t_1; elseif (a <= -7e-86) tmp = Float64(y4 * Float64(b * Float64(Float64(t * j) - Float64(y * k)))); elseif (a <= -9.5e-209) tmp = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))); elseif (a <= 4.95e-293) tmp = t_2; elseif (a <= 6.6e-153) tmp = Float64(Float64(c * y2) * fma(Float64(-t), y4, Float64(x * y0))); elseif (a <= 3.45) tmp = Float64(Float64(z * c) * fma(t, i, Float64(y0 * Float64(-y3)))); elseif (a <= 5e+63) tmp = t_2; elseif (a <= 1e+279) tmp = t_1; else tmp = Float64(y2 * Float64(y5 * Float64(Float64(t * a) - Float64(k * y0)))); 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[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -5.4e+72], t$95$1, If[LessEqual[a, -7e-86], N[(y4 * N[(b * N[(N[(t * j), $MachinePrecision] - N[(y * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -9.5e-209], N[(N[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 4.95e-293], t$95$2, If[LessEqual[a, 6.6e-153], N[(N[(c * y2), $MachinePrecision] * N[((-t) * y4 + N[(x * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.45], N[(N[(z * c), $MachinePrecision] * N[(t * i + N[(y0 * (-y3)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5e+63], t$95$2, If[LessEqual[a, 1e+279], t$95$1, N[(y2 * N[(y5 * N[(N[(t * a), $MachinePrecision] - N[(k * y0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y1 \cdot \left(a \cdot \left(z \cdot y3 - x \cdot y2\right)\right)\\
t_2 := \left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{if}\;a \leq -5.4 \cdot 10^{+72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq -7 \cdot 10^{-86}:\\
\;\;\;\;y4 \cdot \left(b \cdot \left(t \cdot j - y \cdot k\right)\right)\\
\mathbf{elif}\;a \leq -9.5 \cdot 10^{-209}:\\
\;\;\;\;\left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{elif}\;a \leq 4.95 \cdot 10^{-293}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 6.6 \cdot 10^{-153}:\\
\;\;\;\;\left(c \cdot y2\right) \cdot \mathsf{fma}\left(-t, y4, x \cdot y0\right)\\
\mathbf{elif}\;a \leq 3.45:\\
\;\;\;\;\left(z \cdot c\right) \cdot \mathsf{fma}\left(t, i, y0 \cdot \left(-y3\right)\right)\\
\mathbf{elif}\;a \leq 5 \cdot 10^{+63}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 10^{+279}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y2 \cdot \left(y5 \cdot \left(t \cdot a - k \cdot y0\right)\right)\\
\end{array}
\end{array}
if a < -5.4000000000000001e72 or 5.00000000000000011e63 < a < 1.00000000000000006e279Initial program 20.4%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites54.4%
Taylor expanded in a around inf
Applied rewrites60.1%
if -5.4000000000000001e72 < a < -7.00000000000000041e-86Initial program 22.9%
Taylor expanded in y4 around inf
lower-*.f64N/A
lower--.f64N/A
Applied rewrites39.5%
Taylor expanded in b around inf
Applied rewrites52.5%
if -7.00000000000000041e-86 < a < -9.50000000000000028e-209Initial program 18.5%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites50.2%
Taylor expanded in y0 around inf
Applied rewrites50.7%
if -9.50000000000000028e-209 < a < 4.9500000000000001e-293 or 3.4500000000000002 < a < 5.00000000000000011e63Initial program 31.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites50.7%
Taylor expanded in i around inf
Applied rewrites35.5%
Taylor expanded in j around 0
Applied rewrites27.9%
Taylor expanded in k around inf
Applied rewrites58.9%
if 4.9500000000000001e-293 < a < 6.59999999999999975e-153Initial program 46.3%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites33.3%
Taylor expanded in y2 around -inf
Applied rewrites44.2%
if 6.59999999999999975e-153 < a < 3.4500000000000002Initial program 32.4%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites43.7%
Taylor expanded in z around -inf
Applied rewrites44.1%
if 1.00000000000000006e279 < a Initial program 27.3%
Taylor expanded in y5 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites63.6%
Taylor expanded in y2 around -inf
Applied rewrites81.8%
Final simplification55.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* a (* b (- (* x y) (* z t))))))
(if (<= y1 -7.8e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.25e+30)
(* (* k y1) (fma y2 y4 (* z (- i))))
(if (<= y1 -5.4e-211)
(* a (* y5 (- (* t y2) (* y y3))))
(if (<= y1 -8.2e-252)
(* (* z c) (fma t i (* y0 (- y3))))
(if (<= y1 1.25e-231)
t_1
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
t_1
(* (* j y1) (fma (- y3) y4 (* x i))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = a * (b * ((x * y) - (z * t)));
double tmp;
if (y1 <= -7.8e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.25e+30) {
tmp = (k * y1) * fma(y2, y4, (z * -i));
} else if (y1 <= -5.4e-211) {
tmp = a * (y5 * ((t * y2) - (y * y3)));
} else if (y1 <= -8.2e-252) {
tmp = (z * c) * fma(t, i, (y0 * -y3));
} else if (y1 <= 1.25e-231) {
tmp = t_1;
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = t_1;
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(a * Float64(b * Float64(Float64(x * y) - Float64(z * t)))) tmp = 0.0 if (y1 <= -7.8e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.25e+30) tmp = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))); elseif (y1 <= -5.4e-211) tmp = Float64(a * Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))); elseif (y1 <= -8.2e-252) tmp = Float64(Float64(z * c) * fma(t, i, Float64(y0 * Float64(-y3)))); elseif (y1 <= 1.25e-231) tmp = t_1; elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = t_1; else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(a * N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y1, -7.8e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.25e+30], N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -5.4e-211], N[(a * N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -8.2e-252], N[(N[(z * c), $MachinePrecision] * N[(t * i + N[(y0 * (-y3)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.25e-231], t$95$1, If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], t$95$1, N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y - z \cdot t\right)\right)\\
\mathbf{if}\;y1 \leq -7.8 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.25 \cdot 10^{+30}:\\
\;\;\;\;\left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{elif}\;y1 \leq -5.4 \cdot 10^{-211}:\\
\;\;\;\;a \cdot \left(y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -8.2 \cdot 10^{-252}:\\
\;\;\;\;\left(z \cdot c\right) \cdot \mathsf{fma}\left(t, i, y0 \cdot \left(-y3\right)\right)\\
\mathbf{elif}\;y1 \leq 1.25 \cdot 10^{-231}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -7.7999999999999998e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -7.7999999999999998e233 < y1 < -1.25e30Initial program 21.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites60.7%
Taylor expanded in i around inf
Applied rewrites44.9%
Taylor expanded in j around 0
Applied rewrites31.5%
Taylor expanded in k around inf
Applied rewrites52.0%
if -1.25e30 < y1 < -5.3999999999999998e-211Initial program 40.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites41.1%
Taylor expanded in b around inf
Applied rewrites20.4%
Taylor expanded in y5 around inf
Applied rewrites43.8%
if -5.3999999999999998e-211 < y1 < -8.20000000000000028e-252Initial program 50.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in z around -inf
Applied rewrites37.0%
if -8.20000000000000028e-252 < y1 < 1.25000000000000006e-231 or 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 21.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites48.4%
Taylor expanded in b around inf
Applied rewrites47.6%
if 1.25000000000000006e-231 < y1 < 4.70000000000000022e-136Initial program 28.0%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites66.7%
Taylor expanded in y5 around inf
Applied rewrites67.3%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification51.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* a (* b (- (* x y) (* z t))))))
(if (<= y1 -7.8e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.25e+30)
(* (* k y1) (fma y2 y4 (* z (- i))))
(if (<= y1 -5.4e-211)
(* (- (* t y2) (* y y3)) (* a y5))
(if (<= y1 -8.2e-252)
(* (* z c) (fma t i (* y0 (- y3))))
(if (<= y1 1.25e-231)
t_1
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
t_1
(* (* j y1) (fma (- y3) y4 (* x i))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = a * (b * ((x * y) - (z * t)));
double tmp;
if (y1 <= -7.8e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.25e+30) {
tmp = (k * y1) * fma(y2, y4, (z * -i));
} else if (y1 <= -5.4e-211) {
tmp = ((t * y2) - (y * y3)) * (a * y5);
} else if (y1 <= -8.2e-252) {
tmp = (z * c) * fma(t, i, (y0 * -y3));
} else if (y1 <= 1.25e-231) {
tmp = t_1;
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = t_1;
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(a * Float64(b * Float64(Float64(x * y) - Float64(z * t)))) tmp = 0.0 if (y1 <= -7.8e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.25e+30) tmp = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))); elseif (y1 <= -5.4e-211) tmp = Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(a * y5)); elseif (y1 <= -8.2e-252) tmp = Float64(Float64(z * c) * fma(t, i, Float64(y0 * Float64(-y3)))); elseif (y1 <= 1.25e-231) tmp = t_1; elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = t_1; else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(a * N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y1, -7.8e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.25e+30], N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -5.4e-211], N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(a * y5), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -8.2e-252], N[(N[(z * c), $MachinePrecision] * N[(t * i + N[(y0 * (-y3)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.25e-231], t$95$1, If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], t$95$1, N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y - z \cdot t\right)\right)\\
\mathbf{if}\;y1 \leq -7.8 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.25 \cdot 10^{+30}:\\
\;\;\;\;\left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{elif}\;y1 \leq -5.4 \cdot 10^{-211}:\\
\;\;\;\;\left(t \cdot y2 - y \cdot y3\right) \cdot \left(a \cdot y5\right)\\
\mathbf{elif}\;y1 \leq -8.2 \cdot 10^{-252}:\\
\;\;\;\;\left(z \cdot c\right) \cdot \mathsf{fma}\left(t, i, y0 \cdot \left(-y3\right)\right)\\
\mathbf{elif}\;y1 \leq 1.25 \cdot 10^{-231}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -7.7999999999999998e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -7.7999999999999998e233 < y1 < -1.25e30Initial program 21.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites60.7%
Taylor expanded in i around inf
Applied rewrites44.9%
Taylor expanded in j around 0
Applied rewrites31.5%
Taylor expanded in k around inf
Applied rewrites52.0%
if -1.25e30 < y1 < -5.3999999999999998e-211Initial program 40.5%
Taylor expanded in y5 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites57.7%
Taylor expanded in a around inf
Applied rewrites43.8%
if -5.3999999999999998e-211 < y1 < -8.20000000000000028e-252Initial program 50.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in z around -inf
Applied rewrites37.0%
if -8.20000000000000028e-252 < y1 < 1.25000000000000006e-231 or 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 21.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites48.4%
Taylor expanded in b around inf
Applied rewrites47.6%
if 1.25000000000000006e-231 < y1 < 4.70000000000000022e-136Initial program 28.0%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites66.7%
Taylor expanded in y5 around inf
Applied rewrites67.3%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification51.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* a (* b (- (* x y) (* z t))))) (t_2 (fma (- y3) y4 (* x i))))
(if (<= y1 -2.35e+30)
(* y1 (* a (- (* z y3) (* x y2))))
(if (<= y1 -1e-210)
(* a (* y5 (- (* t y2) (* y y3))))
(if (<= y1 -4.2e-286)
(* y1 (* j t_2))
(if (<= y1 1.25e-231)
t_1
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103) t_1 (* (* j y1) 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 = a * (b * ((x * y) - (z * t)));
double t_2 = fma(-y3, y4, (x * i));
double tmp;
if (y1 <= -2.35e+30) {
tmp = y1 * (a * ((z * y3) - (x * y2)));
} else if (y1 <= -1e-210) {
tmp = a * (y5 * ((t * y2) - (y * y3)));
} else if (y1 <= -4.2e-286) {
tmp = y1 * (j * t_2);
} else if (y1 <= 1.25e-231) {
tmp = t_1;
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = t_1;
} else {
tmp = (j * y1) * t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(a * Float64(b * Float64(Float64(x * y) - Float64(z * t)))) t_2 = fma(Float64(-y3), y4, Float64(x * i)) tmp = 0.0 if (y1 <= -2.35e+30) tmp = Float64(y1 * Float64(a * Float64(Float64(z * y3) - Float64(x * y2)))); elseif (y1 <= -1e-210) tmp = Float64(a * Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))); elseif (y1 <= -4.2e-286) tmp = Float64(y1 * Float64(j * t_2)); elseif (y1 <= 1.25e-231) tmp = t_1; elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = t_1; else tmp = Float64(Float64(j * y1) * 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[(a * N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y1, -2.35e+30], N[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1e-210], N[(a * N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -4.2e-286], N[(y1 * N[(j * t$95$2), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.25e-231], t$95$1, If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], t$95$1, N[(N[(j * y1), $MachinePrecision] * t$95$2), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y - z \cdot t\right)\right)\\
t_2 := \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\mathbf{if}\;y1 \leq -2.35 \cdot 10^{+30}:\\
\;\;\;\;y1 \cdot \left(a \cdot \left(z \cdot y3 - x \cdot y2\right)\right)\\
\mathbf{elif}\;y1 \leq -1 \cdot 10^{-210}:\\
\;\;\;\;a \cdot \left(y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -4.2 \cdot 10^{-286}:\\
\;\;\;\;y1 \cdot \left(j \cdot t\_2\right)\\
\mathbf{elif}\;y1 \leq 1.25 \cdot 10^{-231}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot t\_2\\
\end{array}
\end{array}
if y1 < -2.34999999999999995e30Initial program 18.4%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites65.2%
Taylor expanded in a around inf
Applied rewrites55.7%
if -2.34999999999999995e30 < y1 < -1e-210Initial program 40.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites41.1%
Taylor expanded in b around inf
Applied rewrites20.4%
Taylor expanded in y5 around inf
Applied rewrites43.8%
if -1e-210 < y1 < -4.19999999999999977e-286Initial program 40.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites31.0%
Taylor expanded in j around inf
Applied rewrites36.4%
if -4.19999999999999977e-286 < y1 < 1.25000000000000006e-231 or 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 21.9%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites49.6%
Taylor expanded in b around inf
Applied rewrites50.1%
if 1.25000000000000006e-231 < y1 < 4.70000000000000022e-136Initial program 28.0%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites66.7%
Taylor expanded in y5 around inf
Applied rewrites67.3%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification51.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* a (* b (- (* x y) (* z t))))))
(if (<= y1 -2.35e+30)
(* y1 (* a (- (* z y3) (* x y2))))
(if (<= y1 -5.4e-211)
(* a (* y5 (- (* t y2) (* y y3))))
(if (<= y1 -8.2e-252)
(* (* z c) (fma t i (* y0 (- y3))))
(if (<= y1 1.25e-231)
t_1
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
t_1
(* (* j y1) (fma (- y3) y4 (* x i)))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = a * (b * ((x * y) - (z * t)));
double tmp;
if (y1 <= -2.35e+30) {
tmp = y1 * (a * ((z * y3) - (x * y2)));
} else if (y1 <= -5.4e-211) {
tmp = a * (y5 * ((t * y2) - (y * y3)));
} else if (y1 <= -8.2e-252) {
tmp = (z * c) * fma(t, i, (y0 * -y3));
} else if (y1 <= 1.25e-231) {
tmp = t_1;
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = t_1;
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(a * Float64(b * Float64(Float64(x * y) - Float64(z * t)))) tmp = 0.0 if (y1 <= -2.35e+30) tmp = Float64(y1 * Float64(a * Float64(Float64(z * y3) - Float64(x * y2)))); elseif (y1 <= -5.4e-211) tmp = Float64(a * Float64(y5 * Float64(Float64(t * y2) - Float64(y * y3)))); elseif (y1 <= -8.2e-252) tmp = Float64(Float64(z * c) * fma(t, i, Float64(y0 * Float64(-y3)))); elseif (y1 <= 1.25e-231) tmp = t_1; elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = t_1; else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(a * N[(b * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y1, -2.35e+30], N[(y1 * N[(a * N[(N[(z * y3), $MachinePrecision] - N[(x * y2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -5.4e-211], N[(a * N[(y5 * N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -8.2e-252], N[(N[(z * c), $MachinePrecision] * N[(t * i + N[(y0 * (-y3)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.25e-231], t$95$1, If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], t$95$1, N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y - z \cdot t\right)\right)\\
\mathbf{if}\;y1 \leq -2.35 \cdot 10^{+30}:\\
\;\;\;\;y1 \cdot \left(a \cdot \left(z \cdot y3 - x \cdot y2\right)\right)\\
\mathbf{elif}\;y1 \leq -5.4 \cdot 10^{-211}:\\
\;\;\;\;a \cdot \left(y5 \cdot \left(t \cdot y2 - y \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -8.2 \cdot 10^{-252}:\\
\;\;\;\;\left(z \cdot c\right) \cdot \mathsf{fma}\left(t, i, y0 \cdot \left(-y3\right)\right)\\
\mathbf{elif}\;y1 \leq 1.25 \cdot 10^{-231}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -2.34999999999999995e30Initial program 18.4%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites65.2%
Taylor expanded in a around inf
Applied rewrites55.7%
if -2.34999999999999995e30 < y1 < -5.3999999999999998e-211Initial program 40.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites41.1%
Taylor expanded in b around inf
Applied rewrites20.4%
Taylor expanded in y5 around inf
Applied rewrites43.8%
if -5.3999999999999998e-211 < y1 < -8.20000000000000028e-252Initial program 50.0%
Taylor expanded in c around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites50.5%
Taylor expanded in z around -inf
Applied rewrites37.0%
if -8.20000000000000028e-252 < y1 < 1.25000000000000006e-231 or 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 21.5%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites48.4%
Taylor expanded in b around inf
Applied rewrites47.6%
if 1.25000000000000006e-231 < y1 < 4.70000000000000022e-136Initial program 28.0%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites66.7%
Taylor expanded in y5 around inf
Applied rewrites67.3%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification51.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -7.8e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.25e+30)
(* (* k y1) (fma y2 y4 (* z (- i))))
(if (<= y1 -3.1e-211)
(* (- (* t y2) (* y y3)) (* a y5))
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
(* (* a b) (- (* x y) (* z t)))
(* (* j y1) (fma (- y3) y4 (* x i)))))))))
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 (y1 <= -7.8e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.25e+30) {
tmp = (k * y1) * fma(y2, y4, (z * -i));
} else if (y1 <= -3.1e-211) {
tmp = ((t * y2) - (y * y3)) * (a * y5);
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -7.8e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.25e+30) tmp = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))); elseif (y1 <= -3.1e-211) tmp = Float64(Float64(Float64(t * y2) - Float64(y * y3)) * Float64(a * y5)); elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -7.8e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.25e+30], N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -3.1e-211], N[(N[(N[(t * y2), $MachinePrecision] - N[(y * y3), $MachinePrecision]), $MachinePrecision] * N[(a * y5), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -7.8 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.25 \cdot 10^{+30}:\\
\;\;\;\;\left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{elif}\;y1 \leq -3.1 \cdot 10^{-211}:\\
\;\;\;\;\left(t \cdot y2 - y \cdot y3\right) \cdot \left(a \cdot y5\right)\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -7.7999999999999998e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -7.7999999999999998e233 < y1 < -1.25e30Initial program 21.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites60.7%
Taylor expanded in i around inf
Applied rewrites44.9%
Taylor expanded in j around 0
Applied rewrites31.5%
Taylor expanded in k around inf
Applied rewrites52.0%
if -1.25e30 < y1 < -3.09999999999999995e-211Initial program 41.8%
Taylor expanded in y5 around -inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
Applied rewrites56.5%
Taylor expanded in a around inf
Applied rewrites43.0%
if -3.09999999999999995e-211 < y1 < 4.70000000000000022e-136Initial program 26.1%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites50.4%
Taylor expanded in y5 around inf
Applied rewrites35.8%
if 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 25.1%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.2%
Taylor expanded in b around inf
Applied rewrites40.9%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification46.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* k y5) (fma i y (* y0 (- y2))))))
(if (<= k -0.85)
t_1
(if (<= k -1.85e-149)
(* (* x y0) (- (* c y2) (* b j)))
(if (<= k -1e-286)
(* y1 (- (* j (* y3 y4))))
(if (<= k 8.6e-128)
(* (* t a) (fma y2 y5 (- (* z b))))
(if (<= k 1.15e+20) (* (* k y0) (fma b z (* y2 (- y5)))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (k * y5) * fma(i, y, (y0 * -y2));
double tmp;
if (k <= -0.85) {
tmp = t_1;
} else if (k <= -1.85e-149) {
tmp = (x * y0) * ((c * y2) - (b * j));
} else if (k <= -1e-286) {
tmp = y1 * -(j * (y3 * y4));
} else if (k <= 8.6e-128) {
tmp = (t * a) * fma(y2, y5, -(z * b));
} else if (k <= 1.15e+20) {
tmp = (k * y0) * fma(b, z, (y2 * -y5));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))) tmp = 0.0 if (k <= -0.85) tmp = t_1; elseif (k <= -1.85e-149) tmp = Float64(Float64(x * y0) * Float64(Float64(c * y2) - Float64(b * j))); elseif (k <= -1e-286) tmp = Float64(y1 * Float64(-Float64(j * Float64(y3 * y4)))); elseif (k <= 8.6e-128) tmp = Float64(Float64(t * a) * fma(y2, y5, Float64(-Float64(z * b)))); elseif (k <= 1.15e+20) tmp = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -0.85], t$95$1, If[LessEqual[k, -1.85e-149], N[(N[(x * y0), $MachinePrecision] * N[(N[(c * y2), $MachinePrecision] - N[(b * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, -1e-286], N[(y1 * (-N[(j * N[(y3 * y4), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[k, 8.6e-128], N[(N[(t * a), $MachinePrecision] * N[(y2 * y5 + (-N[(z * b), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.15e+20], N[(N[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{if}\;k \leq -0.85:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -1.85 \cdot 10^{-149}:\\
\;\;\;\;\left(x \cdot y0\right) \cdot \left(c \cdot y2 - b \cdot j\right)\\
\mathbf{elif}\;k \leq -1 \cdot 10^{-286}:\\
\;\;\;\;y1 \cdot \left(-j \cdot \left(y3 \cdot y4\right)\right)\\
\mathbf{elif}\;k \leq 8.6 \cdot 10^{-128}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \mathsf{fma}\left(y2, y5, -z \cdot b\right)\\
\mathbf{elif}\;k \leq 1.15 \cdot 10^{+20}:\\
\;\;\;\;\left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -0.849999999999999978 or 1.15e20 < k Initial program 27.2%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites56.8%
Taylor expanded in y5 around inf
Applied rewrites43.8%
if -0.849999999999999978 < k < -1.84999999999999995e-149Initial program 33.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6454.7
Applied rewrites54.7%
Taylor expanded in y0 around inf
Applied rewrites46.9%
if -1.84999999999999995e-149 < k < -1.00000000000000005e-286Initial program 28.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites47.0%
Taylor expanded in i around inf
Applied rewrites12.0%
Taylor expanded in y4 around inf
Applied rewrites44.2%
Taylor expanded in k around 0
Applied rewrites44.1%
if -1.00000000000000005e-286 < k < 8.59999999999999988e-128Initial program 24.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites65.9%
Taylor expanded in b around inf
Applied rewrites29.0%
Taylor expanded in x around inf
Applied rewrites8.7%
Taylor expanded in t around inf
Applied rewrites49.2%
if 8.59999999999999988e-128 < k < 1.15e20Initial program 23.4%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites37.7%
Taylor expanded in y0 around inf
Applied rewrites40.9%
Final simplification44.3%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -7.8e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.2e-15)
(* (* k y1) (fma y2 y4 (* z (- i))))
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
(* (* a b) (- (* x y) (* z t)))
(* (* j y1) (fma (- y3) y4 (* x i))))))))
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 (y1 <= -7.8e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.2e-15) {
tmp = (k * y1) * fma(y2, y4, (z * -i));
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -7.8e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.2e-15) tmp = Float64(Float64(k * y1) * fma(y2, y4, Float64(z * Float64(-i)))); elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -7.8e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.2e-15], N[(N[(k * y1), $MachinePrecision] * N[(y2 * y4 + N[(z * (-i)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -7.8 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.2 \cdot 10^{-15}:\\
\;\;\;\;\left(k \cdot y1\right) \cdot \mathsf{fma}\left(y2, y4, z \cdot \left(-i\right)\right)\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -7.7999999999999998e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -7.7999999999999998e233 < y1 < -1.19999999999999997e-15Initial program 23.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites54.4%
Taylor expanded in i around inf
Applied rewrites40.5%
Taylor expanded in j around 0
Applied rewrites28.4%
Taylor expanded in k around inf
Applied rewrites49.0%
if -1.19999999999999997e-15 < y1 < 4.70000000000000022e-136Initial program 32.8%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites46.9%
Taylor expanded in y5 around inf
Applied rewrites35.8%
if 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 25.1%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.2%
Taylor expanded in b around inf
Applied rewrites40.9%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification45.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -5.9e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -8.2e+17)
(* (- (* x j) (* z k)) (* i y1))
(if (<= y1 4.7e-136)
(* (* k y5) (fma i y (* y0 (- y2))))
(if (<= y1 3.7e+103)
(* (* a b) (- (* x y) (* z t)))
(* (* j y1) (fma (- y3) y4 (* x i))))))))
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 (y1 <= -5.9e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -8.2e+17) {
tmp = ((x * j) - (z * k)) * (i * y1);
} else if (y1 <= 4.7e-136) {
tmp = (k * y5) * fma(i, y, (y0 * -y2));
} else if (y1 <= 3.7e+103) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = (j * y1) * fma(-y3, y4, (x * i));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -5.9e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -8.2e+17) tmp = Float64(Float64(Float64(x * j) - Float64(z * k)) * Float64(i * y1)); elseif (y1 <= 4.7e-136) tmp = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))); elseif (y1 <= 3.7e+103) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); else tmp = Float64(Float64(j * y1) * fma(Float64(-y3), y4, Float64(x * i))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -5.9e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -8.2e+17], N[(N[(N[(x * j), $MachinePrecision] - N[(z * k), $MachinePrecision]), $MachinePrecision] * N[(i * y1), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 4.7e-136], N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 3.7e+103], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(j * y1), $MachinePrecision] * N[((-y3) * y4 + N[(x * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -5.9 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -8.2 \cdot 10^{+17}:\\
\;\;\;\;\left(x \cdot j - z \cdot k\right) \cdot \left(i \cdot y1\right)\\
\mathbf{elif}\;y1 \leq 4.7 \cdot 10^{-136}:\\
\;\;\;\;\left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{elif}\;y1 \leq 3.7 \cdot 10^{+103}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;\left(j \cdot y1\right) \cdot \mathsf{fma}\left(-y3, y4, x \cdot i\right)\\
\end{array}
\end{array}
if y1 < -5.90000000000000026e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -5.90000000000000026e233 < y1 < -8.2e17Initial program 24.0%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites56.8%
Taylor expanded in i around inf
Applied rewrites42.2%
if -8.2e17 < y1 < 4.70000000000000022e-136Initial program 32.2%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites46.0%
Taylor expanded in y5 around inf
Applied rewrites36.1%
if 4.70000000000000022e-136 < y1 < 3.70000000000000033e103Initial program 25.1%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.2%
Taylor expanded in b around inf
Applied rewrites40.9%
if 3.70000000000000033e103 < y1 Initial program 26.2%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites64.6%
Taylor expanded in j around inf
Applied rewrites57.5%
Final simplification43.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* k y5) (fma i y (* y0 (- y2))))))
(if (<= k -1.85e-149)
t_1
(if (<= k -1e-286)
(* y1 (- (* j (* y3 y4))))
(if (<= k 8.6e-128)
(* (* t a) (fma y2 y5 (- (* z b))))
(if (<= k 1.15e+20) (* (* k y0) (fma b z (* y2 (- y5)))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (k * y5) * fma(i, y, (y0 * -y2));
double tmp;
if (k <= -1.85e-149) {
tmp = t_1;
} else if (k <= -1e-286) {
tmp = y1 * -(j * (y3 * y4));
} else if (k <= 8.6e-128) {
tmp = (t * a) * fma(y2, y5, -(z * b));
} else if (k <= 1.15e+20) {
tmp = (k * y0) * fma(b, z, (y2 * -y5));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(k * y5) * fma(i, y, Float64(y0 * Float64(-y2)))) tmp = 0.0 if (k <= -1.85e-149) tmp = t_1; elseif (k <= -1e-286) tmp = Float64(y1 * Float64(-Float64(j * Float64(y3 * y4)))); elseif (k <= 8.6e-128) tmp = Float64(Float64(t * a) * fma(y2, y5, Float64(-Float64(z * b)))); elseif (k <= 1.15e+20) tmp = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := Block[{t$95$1 = N[(N[(k * y5), $MachinePrecision] * N[(i * y + N[(y0 * (-y2)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -1.85e-149], t$95$1, If[LessEqual[k, -1e-286], N[(y1 * (-N[(j * N[(y3 * y4), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[k, 8.6e-128], N[(N[(t * a), $MachinePrecision] * N[(y2 * y5 + (-N[(z * b), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.15e+20], N[(N[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(k \cdot y5\right) \cdot \mathsf{fma}\left(i, y, y0 \cdot \left(-y2\right)\right)\\
\mathbf{if}\;k \leq -1.85 \cdot 10^{-149}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq -1 \cdot 10^{-286}:\\
\;\;\;\;y1 \cdot \left(-j \cdot \left(y3 \cdot y4\right)\right)\\
\mathbf{elif}\;k \leq 8.6 \cdot 10^{-128}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \mathsf{fma}\left(y2, y5, -z \cdot b\right)\\
\mathbf{elif}\;k \leq 1.15 \cdot 10^{+20}:\\
\;\;\;\;\left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if k < -1.84999999999999995e-149 or 1.15e20 < k Initial program 28.0%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites52.9%
Taylor expanded in y5 around inf
Applied rewrites41.3%
if -1.84999999999999995e-149 < k < -1.00000000000000005e-286Initial program 28.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites47.0%
Taylor expanded in i around inf
Applied rewrites12.0%
Taylor expanded in y4 around inf
Applied rewrites44.2%
Taylor expanded in k around 0
Applied rewrites44.1%
if -1.00000000000000005e-286 < k < 8.59999999999999988e-128Initial program 24.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites65.9%
Taylor expanded in b around inf
Applied rewrites29.0%
Taylor expanded in x around inf
Applied rewrites8.7%
Taylor expanded in t around inf
Applied rewrites49.2%
if 8.59999999999999988e-128 < k < 1.15e20Initial program 23.4%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites37.7%
Taylor expanded in y0 around inf
Applied rewrites40.9%
Final simplification42.4%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* k y0) (fma b z (* y2 (- y5))))))
(if (<= k -4200000.0)
t_1
(if (<= k 1.65e-284)
(* (* a b) (- (* x y) (* z t)))
(if (<= k 8.6e-128)
(* (* t a) (fma y2 y5 (- (* z b))))
(if (<= k 9e+20) t_1 (* (* k y2) (- (* y1 y4) (* y0 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 t_1 = (k * y0) * fma(b, z, (y2 * -y5));
double tmp;
if (k <= -4200000.0) {
tmp = t_1;
} else if (k <= 1.65e-284) {
tmp = (a * b) * ((x * y) - (z * t));
} else if (k <= 8.6e-128) {
tmp = (t * a) * fma(y2, y5, -(z * b));
} else if (k <= 9e+20) {
tmp = t_1;
} else {
tmp = (k * y2) * ((y1 * y4) - (y0 * y5));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))) tmp = 0.0 if (k <= -4200000.0) tmp = t_1; elseif (k <= 1.65e-284) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); elseif (k <= 8.6e-128) tmp = Float64(Float64(t * a) * fma(y2, y5, Float64(-Float64(z * b)))); elseif (k <= 9e+20) tmp = t_1; else tmp = Float64(Float64(k * y2) * Float64(Float64(y1 * y4) - Float64(y0 * y5))); 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[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -4200000.0], t$95$1, If[LessEqual[k, 1.65e-284], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 8.6e-128], N[(N[(t * a), $MachinePrecision] * N[(y2 * y5 + (-N[(z * b), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 9e+20], t$95$1, N[(N[(k * y2), $MachinePrecision] * N[(N[(y1 * y4), $MachinePrecision] - N[(y0 * y5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{if}\;k \leq -4200000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 1.65 \cdot 10^{-284}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{elif}\;k \leq 8.6 \cdot 10^{-128}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \mathsf{fma}\left(y2, y5, -z \cdot b\right)\\
\mathbf{elif}\;k \leq 9 \cdot 10^{+20}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(k \cdot y2\right) \cdot \left(y1 \cdot y4 - y0 \cdot y5\right)\\
\end{array}
\end{array}
if k < -4.2e6 or 8.59999999999999988e-128 < k < 9e20Initial program 22.3%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites49.4%
Taylor expanded in y0 around inf
Applied rewrites44.4%
if -4.2e6 < k < 1.65000000000000004e-284Initial program 26.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites52.1%
Taylor expanded in b around inf
Applied rewrites36.1%
if 1.65000000000000004e-284 < k < 8.59999999999999988e-128Initial program 33.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites57.7%
Taylor expanded in b around inf
Applied rewrites20.8%
Taylor expanded in x around inf
Applied rewrites2.0%
Taylor expanded in t around inf
Applied rewrites53.6%
if 9e20 < k Initial program 32.5%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites58.2%
Taylor expanded in y2 around inf
Applied rewrites40.2%
Final simplification42.0%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(let* ((t_1 (* (* k y0) (fma b z (* y2 (- y5))))))
(if (<= k -4200000.0)
t_1
(if (<= k 1.65e-284)
(* (* a b) (- (* x y) (* z t)))
(if (<= k 8.6e-128)
(* (* t a) (fma y2 y5 (- (* z b))))
(if (<= k 3.4e+202) t_1 (* y1 (- (* z (* i k))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = (k * y0) * fma(b, z, (y2 * -y5));
double tmp;
if (k <= -4200000.0) {
tmp = t_1;
} else if (k <= 1.65e-284) {
tmp = (a * b) * ((x * y) - (z * t));
} else if (k <= 8.6e-128) {
tmp = (t * a) * fma(y2, y5, -(z * b));
} else if (k <= 3.4e+202) {
tmp = t_1;
} else {
tmp = y1 * -(z * (i * k));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(Float64(k * y0) * fma(b, z, Float64(y2 * Float64(-y5)))) tmp = 0.0 if (k <= -4200000.0) tmp = t_1; elseif (k <= 1.65e-284) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); elseif (k <= 8.6e-128) tmp = Float64(Float64(t * a) * fma(y2, y5, Float64(-Float64(z * b)))); elseif (k <= 3.4e+202) tmp = t_1; else tmp = Float64(y1 * Float64(-Float64(z * Float64(i * k)))); 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[(k * y0), $MachinePrecision] * N[(b * z + N[(y2 * (-y5)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, -4200000.0], t$95$1, If[LessEqual[k, 1.65e-284], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 8.6e-128], N[(N[(t * a), $MachinePrecision] * N[(y2 * y5 + (-N[(z * b), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.4e+202], t$95$1, N[(y1 * (-N[(z * N[(i * k), $MachinePrecision]), $MachinePrecision])), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(k \cdot y0\right) \cdot \mathsf{fma}\left(b, z, y2 \cdot \left(-y5\right)\right)\\
\mathbf{if}\;k \leq -4200000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;k \leq 1.65 \cdot 10^{-284}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{elif}\;k \leq 8.6 \cdot 10^{-128}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \mathsf{fma}\left(y2, y5, -z \cdot b\right)\\
\mathbf{elif}\;k \leq 3.4 \cdot 10^{+202}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y1 \cdot \left(-z \cdot \left(i \cdot k\right)\right)\\
\end{array}
\end{array}
if k < -4.2e6 or 8.59999999999999988e-128 < k < 3.4e202Initial program 25.2%
Taylor expanded in k around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
Applied rewrites47.7%
Taylor expanded in y0 around inf
Applied rewrites39.6%
if -4.2e6 < k < 1.65000000000000004e-284Initial program 26.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites52.1%
Taylor expanded in b around inf
Applied rewrites36.1%
if 1.65000000000000004e-284 < k < 8.59999999999999988e-128Initial program 33.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites57.7%
Taylor expanded in b around inf
Applied rewrites20.8%
Taylor expanded in x around inf
Applied rewrites2.0%
Taylor expanded in t around inf
Applied rewrites53.6%
if 3.4e202 < k Initial program 33.3%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites37.8%
Taylor expanded in i around inf
Applied rewrites45.3%
Taylor expanded in j around 0
Applied rewrites41.9%
Taylor expanded in j around 0
Applied rewrites49.0%
Final simplification40.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.75e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.75e+54)
(* y1 (* k (* y2 y4)))
(if (<= y1 -6.2e-299)
(* (* t a) (fma y2 y5 (- (* z b))))
(if (<= y1 7e+109)
(* (* a b) (- (* x y) (* z t)))
(* x (* i (* j y1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.75e+54) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= -6.2e-299) {
tmp = (t * a) * fma(y2, y5, -(z * b));
} else if (y1 <= 7e+109) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = x * (i * (j * y1));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.75e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.75e+54) tmp = Float64(y1 * Float64(k * Float64(y2 * y4))); elseif (y1 <= -6.2e-299) tmp = Float64(Float64(t * a) * fma(y2, y5, Float64(-Float64(z * b)))); elseif (y1 <= 7e+109) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); else tmp = Float64(x * Float64(i * Float64(j * y1))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.75e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.75e+54], N[(y1 * N[(k * N[(y2 * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -6.2e-299], N[(N[(t * a), $MachinePrecision] * N[(y2 * y5 + (-N[(z * b), $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 7e+109], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.75 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.75 \cdot 10^{+54}:\\
\;\;\;\;y1 \cdot \left(k \cdot \left(y2 \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq -6.2 \cdot 10^{-299}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \mathsf{fma}\left(y2, y5, -z \cdot b\right)\\
\mathbf{elif}\;y1 \leq 7 \cdot 10^{+109}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\end{array}
\end{array}
if y1 < -1.7499999999999999e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -1.7499999999999999e233 < y1 < -1.7500000000000001e54Initial program 21.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites62.2%
Taylor expanded in i around inf
Applied rewrites46.4%
Taylor expanded in y4 around inf
Applied rewrites49.3%
Taylor expanded in k around inf
Applied rewrites44.3%
if -1.7500000000000001e54 < y1 < -6.1999999999999999e-299Initial program 37.0%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites36.3%
Taylor expanded in b around inf
Applied rewrites16.1%
Taylor expanded in x around inf
Applied rewrites10.9%
Taylor expanded in t around inf
Applied rewrites22.3%
if -6.1999999999999999e-299 < y1 < 6.99999999999999966e109Initial program 24.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites45.8%
Taylor expanded in b around inf
Applied rewrites35.2%
if 6.99999999999999966e109 < y1 Initial program 25.0%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6437.9
Applied rewrites37.9%
Taylor expanded in i around -inf
Applied rewrites45.5%
Taylor expanded in c around 0
Applied rewrites48.1%
Final simplification37.1%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.75e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.9e+54)
(* y1 (* k (* y2 y4)))
(if (<= y1 7e+109)
(* (* a b) (- (* x y) (* z t)))
(* x (* i (* j y1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.9e+54) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 7e+109) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = x * (i * (j * y1));
}
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 (y1 <= (-1.75d+233)) then
tmp = a * (y1 * (z * y3))
else if (y1 <= (-1.9d+54)) then
tmp = y1 * (k * (y2 * y4))
else if (y1 <= 7d+109) then
tmp = (a * b) * ((x * y) - (z * t))
else
tmp = x * (i * (j * y1))
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 (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.9e+54) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 7e+109) {
tmp = (a * b) * ((x * y) - (z * t));
} else {
tmp = x * (i * (j * y1));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if y1 <= -1.75e+233: tmp = a * (y1 * (z * y3)) elif y1 <= -1.9e+54: tmp = y1 * (k * (y2 * y4)) elif y1 <= 7e+109: tmp = (a * b) * ((x * y) - (z * t)) else: tmp = x * (i * (j * y1)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.75e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.9e+54) tmp = Float64(y1 * Float64(k * Float64(y2 * y4))); elseif (y1 <= 7e+109) tmp = Float64(Float64(a * b) * Float64(Float64(x * y) - Float64(z * t))); else tmp = Float64(x * Float64(i * Float64(j * y1))); 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 (y1 <= -1.75e+233) tmp = a * (y1 * (z * y3)); elseif (y1 <= -1.9e+54) tmp = y1 * (k * (y2 * y4)); elseif (y1 <= 7e+109) tmp = (a * b) * ((x * y) - (z * t)); else tmp = x * (i * (j * y1)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.75e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.9e+54], N[(y1 * N[(k * N[(y2 * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 7e+109], N[(N[(a * b), $MachinePrecision] * N[(N[(x * y), $MachinePrecision] - N[(z * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.75 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.9 \cdot 10^{+54}:\\
\;\;\;\;y1 \cdot \left(k \cdot \left(y2 \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 7 \cdot 10^{+109}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y - z \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\end{array}
\end{array}
if y1 < -1.7499999999999999e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -1.7499999999999999e233 < y1 < -1.9000000000000001e54Initial program 21.6%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites62.2%
Taylor expanded in i around inf
Applied rewrites46.4%
Taylor expanded in y4 around inf
Applied rewrites49.3%
Taylor expanded in k around inf
Applied rewrites44.3%
if -1.9000000000000001e54 < y1 < 6.99999999999999966e109Initial program 30.4%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites41.4%
Taylor expanded in b around inf
Applied rewrites26.2%
if 6.99999999999999966e109 < y1 Initial program 25.0%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6437.9
Applied rewrites37.9%
Taylor expanded in i around -inf
Applied rewrites45.5%
Taylor expanded in c around 0
Applied rewrites48.1%
Final simplification35.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.75e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.06e-162)
(* y1 (* k (* y2 y4)))
(if (<= y1 2.5e-297)
(* a (* b (* z (- t))))
(if (<= y1 1.05e+103) (* a (* b (* x y))) (* x (* i (* j y1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.06e-162) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 2.5e-297) {
tmp = a * (b * (z * -t));
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
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 (y1 <= (-1.75d+233)) then
tmp = a * (y1 * (z * y3))
else if (y1 <= (-1.06d-162)) then
tmp = y1 * (k * (y2 * y4))
else if (y1 <= 2.5d-297) then
tmp = a * (b * (z * -t))
else if (y1 <= 1.05d+103) then
tmp = a * (b * (x * y))
else
tmp = x * (i * (j * y1))
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 (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.06e-162) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 2.5e-297) {
tmp = a * (b * (z * -t));
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if y1 <= -1.75e+233: tmp = a * (y1 * (z * y3)) elif y1 <= -1.06e-162: tmp = y1 * (k * (y2 * y4)) elif y1 <= 2.5e-297: tmp = a * (b * (z * -t)) elif y1 <= 1.05e+103: tmp = a * (b * (x * y)) else: tmp = x * (i * (j * y1)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.75e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.06e-162) tmp = Float64(y1 * Float64(k * Float64(y2 * y4))); elseif (y1 <= 2.5e-297) tmp = Float64(a * Float64(b * Float64(z * Float64(-t)))); elseif (y1 <= 1.05e+103) tmp = Float64(a * Float64(b * Float64(x * y))); else tmp = Float64(x * Float64(i * Float64(j * y1))); 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 (y1 <= -1.75e+233) tmp = a * (y1 * (z * y3)); elseif (y1 <= -1.06e-162) tmp = y1 * (k * (y2 * y4)); elseif (y1 <= 2.5e-297) tmp = a * (b * (z * -t)); elseif (y1 <= 1.05e+103) tmp = a * (b * (x * y)); else tmp = x * (i * (j * y1)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.75e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.06e-162], N[(y1 * N[(k * N[(y2 * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 2.5e-297], N[(a * N[(b * N[(z * (-t)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.05e+103], N[(a * N[(b * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.75 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.06 \cdot 10^{-162}:\\
\;\;\;\;y1 \cdot \left(k \cdot \left(y2 \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 2.5 \cdot 10^{-297}:\\
\;\;\;\;a \cdot \left(b \cdot \left(z \cdot \left(-t\right)\right)\right)\\
\mathbf{elif}\;y1 \leq 1.05 \cdot 10^{+103}:\\
\;\;\;\;a \cdot \left(b \cdot \left(x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\end{array}
\end{array}
if y1 < -1.7499999999999999e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -1.7499999999999999e233 < y1 < -1.06000000000000003e-162Initial program 30.3%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites51.8%
Taylor expanded in i around inf
Applied rewrites32.7%
Taylor expanded in y4 around inf
Applied rewrites35.2%
Taylor expanded in k around inf
Applied rewrites28.9%
if -1.06000000000000003e-162 < y1 < 2.5e-297Initial program 34.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites39.2%
Taylor expanded in b around inf
Applied rewrites28.4%
Taylor expanded in x around 0
Applied rewrites28.5%
if 2.5e-297 < y1 < 1.0500000000000001e103Initial program 23.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.7%
Taylor expanded in b around inf
Applied rewrites40.1%
Taylor expanded in x around inf
Applied rewrites28.4%
if 1.0500000000000001e103 < y1 Initial program 26.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6436.2
Applied rewrites36.2%
Taylor expanded in i around -inf
Applied rewrites43.4%
Taylor expanded in c around 0
Applied rewrites45.8%
Final simplification34.2%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.75e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.06e-162)
(* y1 (* k (* y2 y4)))
(if (<= y1 1.5e-297)
(* (* a b) (* z (- t)))
(if (<= y1 1.05e+103) (* a (* b (* x y))) (* x (* i (* j y1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.06e-162) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 1.5e-297) {
tmp = (a * b) * (z * -t);
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
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 (y1 <= (-1.75d+233)) then
tmp = a * (y1 * (z * y3))
else if (y1 <= (-1.06d-162)) then
tmp = y1 * (k * (y2 * y4))
else if (y1 <= 1.5d-297) then
tmp = (a * b) * (z * -t)
else if (y1 <= 1.05d+103) then
tmp = a * (b * (x * y))
else
tmp = x * (i * (j * y1))
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 (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.06e-162) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 1.5e-297) {
tmp = (a * b) * (z * -t);
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if y1 <= -1.75e+233: tmp = a * (y1 * (z * y3)) elif y1 <= -1.06e-162: tmp = y1 * (k * (y2 * y4)) elif y1 <= 1.5e-297: tmp = (a * b) * (z * -t) elif y1 <= 1.05e+103: tmp = a * (b * (x * y)) else: tmp = x * (i * (j * y1)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.75e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.06e-162) tmp = Float64(y1 * Float64(k * Float64(y2 * y4))); elseif (y1 <= 1.5e-297) tmp = Float64(Float64(a * b) * Float64(z * Float64(-t))); elseif (y1 <= 1.05e+103) tmp = Float64(a * Float64(b * Float64(x * y))); else tmp = Float64(x * Float64(i * Float64(j * y1))); 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 (y1 <= -1.75e+233) tmp = a * (y1 * (z * y3)); elseif (y1 <= -1.06e-162) tmp = y1 * (k * (y2 * y4)); elseif (y1 <= 1.5e-297) tmp = (a * b) * (z * -t); elseif (y1 <= 1.05e+103) tmp = a * (b * (x * y)); else tmp = x * (i * (j * y1)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.75e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.06e-162], N[(y1 * N[(k * N[(y2 * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.5e-297], N[(N[(a * b), $MachinePrecision] * N[(z * (-t)), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.05e+103], N[(a * N[(b * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.75 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.06 \cdot 10^{-162}:\\
\;\;\;\;y1 \cdot \left(k \cdot \left(y2 \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 1.5 \cdot 10^{-297}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(z \cdot \left(-t\right)\right)\\
\mathbf{elif}\;y1 \leq 1.05 \cdot 10^{+103}:\\
\;\;\;\;a \cdot \left(b \cdot \left(x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\end{array}
\end{array}
if y1 < -1.7499999999999999e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -1.7499999999999999e233 < y1 < -1.06000000000000003e-162Initial program 30.3%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites51.8%
Taylor expanded in i around inf
Applied rewrites32.7%
Taylor expanded in y4 around inf
Applied rewrites35.2%
Taylor expanded in k around inf
Applied rewrites28.9%
if -1.06000000000000003e-162 < y1 < 1.49999999999999997e-297Initial program 34.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites39.2%
Taylor expanded in b around inf
Applied rewrites22.1%
Taylor expanded in x around 0
Applied rewrites24.2%
if 1.49999999999999997e-297 < y1 < 1.0500000000000001e103Initial program 23.6%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.7%
Taylor expanded in b around inf
Applied rewrites40.1%
Taylor expanded in x around inf
Applied rewrites28.4%
if 1.0500000000000001e103 < y1 Initial program 26.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6436.2
Applied rewrites36.2%
Taylor expanded in i around -inf
Applied rewrites43.4%
Taylor expanded in c around 0
Applied rewrites45.8%
Final simplification33.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5)
:precision binary64
(if (<= y1 -1.75e+233)
(* a (* y1 (* z y3)))
(if (<= y1 -1.75e-304)
(* y1 (* k (* y2 y4)))
(if (<= y1 1.05e+103) (* a (* b (* x y))) (* x (* i (* j y1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double tmp;
if (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.75e-304) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
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 (y1 <= (-1.75d+233)) then
tmp = a * (y1 * (z * y3))
else if (y1 <= (-1.75d-304)) then
tmp = y1 * (k * (y2 * y4))
else if (y1 <= 1.05d+103) then
tmp = a * (b * (x * y))
else
tmp = x * (i * (j * y1))
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 (y1 <= -1.75e+233) {
tmp = a * (y1 * (z * y3));
} else if (y1 <= -1.75e-304) {
tmp = y1 * (k * (y2 * y4));
} else if (y1 <= 1.05e+103) {
tmp = a * (b * (x * y));
} else {
tmp = x * (i * (j * y1));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if y1 <= -1.75e+233: tmp = a * (y1 * (z * y3)) elif y1 <= -1.75e-304: tmp = y1 * (k * (y2 * y4)) elif y1 <= 1.05e+103: tmp = a * (b * (x * y)) else: tmp = x * (i * (j * y1)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (y1 <= -1.75e+233) tmp = Float64(a * Float64(y1 * Float64(z * y3))); elseif (y1 <= -1.75e-304) tmp = Float64(y1 * Float64(k * Float64(y2 * y4))); elseif (y1 <= 1.05e+103) tmp = Float64(a * Float64(b * Float64(x * y))); else tmp = Float64(x * Float64(i * Float64(j * y1))); 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 (y1 <= -1.75e+233) tmp = a * (y1 * (z * y3)); elseif (y1 <= -1.75e-304) tmp = y1 * (k * (y2 * y4)); elseif (y1 <= 1.05e+103) tmp = a * (b * (x * y)); else tmp = x * (i * (j * y1)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[y1, -1.75e+233], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, -1.75e-304], N[(y1 * N[(k * N[(y2 * y4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y1, 1.05e+103], N[(a * N[(b * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y1 \leq -1.75 \cdot 10^{+233}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{elif}\;y1 \leq -1.75 \cdot 10^{-304}:\\
\;\;\;\;y1 \cdot \left(k \cdot \left(y2 \cdot y4\right)\right)\\
\mathbf{elif}\;y1 \leq 1.05 \cdot 10^{+103}:\\
\;\;\;\;a \cdot \left(b \cdot \left(x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\end{array}
\end{array}
if y1 < -1.7499999999999999e233Initial program 11.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites64.7%
Taylor expanded in b around inf
Applied rewrites6.9%
Taylor expanded in z around inf
Applied rewrites65.1%
Taylor expanded in b around 0
Applied rewrites70.8%
if -1.7499999999999999e233 < y1 < -1.75e-304Initial program 31.7%
Taylor expanded in y1 around inf
lower-*.f64N/A
mul-1-negN/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
Applied rewrites39.1%
Taylor expanded in i around inf
Applied rewrites27.7%
Taylor expanded in y4 around inf
Applied rewrites29.2%
Taylor expanded in k around inf
Applied rewrites23.5%
if -1.75e-304 < y1 < 1.0500000000000001e103Initial program 24.0%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites45.5%
Taylor expanded in b around inf
Applied rewrites41.1%
Taylor expanded in x around inf
Applied rewrites28.6%
if 1.0500000000000001e103 < y1 Initial program 26.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6436.2
Applied rewrites36.2%
Taylor expanded in i around -inf
Applied rewrites43.4%
Taylor expanded in c around 0
Applied rewrites45.8%
Final simplification31.9%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (let* ((t_1 (* a (* b (* x y))))) (if (<= b -1.68e+115) t_1 (if (<= b 3.1e+50) (* x (* i (* j 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 = a * (b * (x * y));
double tmp;
if (b <= -1.68e+115) {
tmp = t_1;
} else if (b <= 3.1e+50) {
tmp = x * (i * (j * 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 = a * (b * (x * y))
if (b <= (-1.68d+115)) then
tmp = t_1
else if (b <= 3.1d+50) then
tmp = x * (i * (j * 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 = a * (b * (x * y));
double tmp;
if (b <= -1.68e+115) {
tmp = t_1;
} else if (b <= 3.1e+50) {
tmp = x * (i * (j * 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 = a * (b * (x * y)) tmp = 0 if b <= -1.68e+115: tmp = t_1 elif b <= 3.1e+50: tmp = x * (i * (j * 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(a * Float64(b * Float64(x * y))) tmp = 0.0 if (b <= -1.68e+115) tmp = t_1; elseif (b <= 3.1e+50) tmp = Float64(x * Float64(i * Float64(j * 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 = a * (b * (x * y)); tmp = 0.0; if (b <= -1.68e+115) tmp = t_1; elseif (b <= 3.1e+50) tmp = x * (i * (j * 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[(a * N[(b * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.68e+115], t$95$1, If[LessEqual[b, 3.1e+50], N[(x * N[(i * N[(j * y1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y\right)\right)\\
\mathbf{if}\;b \leq -1.68 \cdot 10^{+115}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 3.1 \cdot 10^{+50}:\\
\;\;\;\;x \cdot \left(i \cdot \left(j \cdot y1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.68e115 or 3.10000000000000003e50 < b Initial program 23.2%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites48.7%
Taylor expanded in b around inf
Applied rewrites48.9%
Taylor expanded in x around inf
Applied rewrites39.2%
if -1.68e115 < b < 3.10000000000000003e50Initial program 29.2%
Taylor expanded in x around inf
lower-*.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f6435.5
Applied rewrites35.5%
Taylor expanded in i around -inf
Applied rewrites29.7%
Taylor expanded in c around 0
Applied rewrites23.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (let* ((t_1 (* a (* b (* x y))))) (if (<= b -7.2e+123) t_1 (if (<= b 1.9e-91) (* a (* y1 (* z y3))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
double t_1 = a * (b * (x * y));
double tmp;
if (b <= -7.2e+123) {
tmp = t_1;
} else if (b <= 1.9e-91) {
tmp = a * (y1 * (z * y3));
} 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 = a * (b * (x * y))
if (b <= (-7.2d+123)) then
tmp = t_1
else if (b <= 1.9d-91) then
tmp = a * (y1 * (z * y3))
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 = a * (b * (x * y));
double tmp;
if (b <= -7.2e+123) {
tmp = t_1;
} else if (b <= 1.9e-91) {
tmp = a * (y1 * (z * y3));
} 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 = a * (b * (x * y)) tmp = 0 if b <= -7.2e+123: tmp = t_1 elif b <= 1.9e-91: tmp = a * (y1 * (z * y3)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) t_1 = Float64(a * Float64(b * Float64(x * y))) tmp = 0.0 if (b <= -7.2e+123) tmp = t_1; elseif (b <= 1.9e-91) tmp = Float64(a * Float64(y1 * Float64(z * y3))); 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 = a * (b * (x * y)); tmp = 0.0; if (b <= -7.2e+123) tmp = t_1; elseif (b <= 1.9e-91) tmp = a * (y1 * (z * y3)); 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[(a * N[(b * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7.2e+123], t$95$1, If[LessEqual[b, 1.9e-91], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot \left(x \cdot y\right)\right)\\
\mathbf{if}\;b \leq -7.2 \cdot 10^{+123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{-91}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -7.19999999999999996e123 or 1.89999999999999989e-91 < b Initial program 24.0%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites49.8%
Taylor expanded in b around inf
Applied rewrites44.8%
Taylor expanded in x around inf
Applied rewrites34.8%
if -7.19999999999999996e123 < b < 1.89999999999999989e-91Initial program 29.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites38.1%
Taylor expanded in b around inf
Applied rewrites14.3%
Taylor expanded in z around inf
Applied rewrites27.2%
Taylor expanded in b around 0
Applied rewrites22.4%
Final simplification27.7%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (if (<= x -2.75e+69) (* (* a b) (* x y)) (if (<= x 1.4e+145) (* a (* y1 (* z y3))) (* b (* a (* x y))))))
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 (x <= -2.75e+69) {
tmp = (a * b) * (x * y);
} else if (x <= 1.4e+145) {
tmp = a * (y1 * (z * y3));
} else {
tmp = b * (a * (x * y));
}
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 (x <= (-2.75d+69)) then
tmp = (a * b) * (x * y)
else if (x <= 1.4d+145) then
tmp = a * (y1 * (z * y3))
else
tmp = b * (a * (x * y))
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 (x <= -2.75e+69) {
tmp = (a * b) * (x * y);
} else if (x <= 1.4e+145) {
tmp = a * (y1 * (z * y3));
} else {
tmp = b * (a * (x * y));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): tmp = 0 if x <= -2.75e+69: tmp = (a * b) * (x * y) elif x <= 1.4e+145: tmp = a * (y1 * (z * y3)) else: tmp = b * (a * (x * y)) return tmp
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = 0.0 if (x <= -2.75e+69) tmp = Float64(Float64(a * b) * Float64(x * y)); elseif (x <= 1.4e+145) tmp = Float64(a * Float64(y1 * Float64(z * y3))); else tmp = Float64(b * Float64(a * Float64(x * y))); 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 (x <= -2.75e+69) tmp = (a * b) * (x * y); elseif (x <= 1.4e+145) tmp = a * (y1 * (z * y3)); else tmp = b * (a * (x * y)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := If[LessEqual[x, -2.75e+69], N[(N[(a * b), $MachinePrecision] * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.4e+145], N[(a * N[(y1 * N[(z * y3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.75 \cdot 10^{+69}:\\
\;\;\;\;\left(a \cdot b\right) \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;x \leq 1.4 \cdot 10^{+145}:\\
\;\;\;\;a \cdot \left(y1 \cdot \left(z \cdot y3\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot \left(x \cdot y\right)\right)\\
\end{array}
\end{array}
if x < -2.75000000000000001e69Initial program 14.8%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites44.5%
Taylor expanded in b around inf
Applied rewrites37.0%
Taylor expanded in x around inf
Applied rewrites37.0%
if -2.75000000000000001e69 < x < 1.3999999999999999e145Initial program 32.4%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites41.8%
Taylor expanded in b around inf
Applied rewrites20.4%
Taylor expanded in z around inf
Applied rewrites30.4%
Taylor expanded in b around 0
Applied rewrites19.9%
if 1.3999999999999999e145 < x Initial program 24.3%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites46.0%
Taylor expanded in b around inf
Applied rewrites30.6%
Taylor expanded in x around inf
Applied rewrites33.1%
Applied rewrites38.2%
Final simplification26.6%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (* b (* a (* x y))))
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 b * (a * (x * y));
}
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 = b * (a * (x * y))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return b * (a * (x * y));
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return b * (a * (x * y))
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(b * Float64(a * Float64(x * y))) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = b * (a * (x * y)); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(b * N[(a * N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
b \cdot \left(a \cdot \left(x \cdot y\right)\right)
\end{array}
Initial program 27.1%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites43.1%
Taylor expanded in b around inf
Applied rewrites23.6%
Taylor expanded in x around inf
Applied rewrites17.1%
Applied rewrites18.5%
Final simplification18.5%
(FPCore (x y z t a b c i j k y0 y1 y2 y3 y4 y5) :precision binary64 (* (* a b) (* x y)))
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 (a * b) * (x * y);
}
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 = (a * b) * (x * y)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j, double k, double y0, double y1, double y2, double y3, double y4, double y5) {
return (a * b) * (x * y);
}
def code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5): return (a * b) * (x * y)
function code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) return Float64(Float64(a * b) * Float64(x * y)) end
function tmp = code(x, y, z, t, a, b, c, i, j, k, y0, y1, y2, y3, y4, y5) tmp = (a * b) * (x * y); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_, k_, y0_, y1_, y2_, y3_, y4_, y5_] := N[(N[(a * b), $MachinePrecision] * N[(x * y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(a \cdot b\right) \cdot \left(x \cdot y\right)
\end{array}
Initial program 27.1%
Taylor expanded in a around inf
lower-*.f64N/A
associate--l+N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower-neg.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
sub-negN/A
Applied rewrites43.1%
Taylor expanded in b around inf
Applied rewrites23.6%
Taylor expanded in x around inf
Applied rewrites17.1%
(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 2024221
(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)))))