
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* c j) (* x a)))
(t_2
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_2 INFINITY) t_2 (* t (cbrt (* t_1 (* t_1 t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (c * j) - (x * a);
double t_2 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = t * cbrt((t_1 * (t_1 * t_1)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (c * j) - (x * a);
double t_2 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = t * Math.cbrt((t_1 * (t_1 * t_1)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(c * j) - Float64(x * a)) t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; else tmp = Float64(t * cbrt(Float64(t_1 * Float64(t_1 * t_1)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(t * N[Power[N[(t$95$1 * N[(t$95$1 * t$95$1), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot j - x \cdot a\\
t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t_2 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t \cdot \sqrt[3]{t_1 \cdot \left(t_1 \cdot t_1\right)}\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 92.6%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
*-commutative0.0%
Simplified0.0%
add-cube-cbrt0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
Applied egg-rr0.0%
Taylor expanded in t around inf 54.3%
*-commutative54.3%
mul-1-neg54.3%
unsub-neg54.3%
Simplified54.3%
add-cbrt-cube60.5%
*-commutative60.5%
*-commutative60.5%
*-commutative60.5%
Applied egg-rr60.5%
Final simplification86.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* t (- (* c j) (* x a))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = t * ((c * j) - (x * a));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = t * ((c * j) - (x * a));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = t * ((c * j) - (x * a)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = t * ((c * j) - (x * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 92.6%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
*-commutative0.0%
Simplified0.0%
add-cube-cbrt0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
*-commutative0.0%
Applied egg-rr0.0%
Taylor expanded in t around inf 54.3%
*-commutative54.3%
mul-1-neg54.3%
unsub-neg54.3%
Simplified54.3%
Final simplification85.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* x (* y z)) (* b (- (* a i) (* z c))))))
(if (<= z -3.35e+38)
t_1
(if (<= z -6.6e-34)
(* t (- (* c j) (* x a)))
(if (or (<= z -2.35e-111) (not (<= z 1.05e+68)))
t_1
(- (* b (* a i)) (* j (- (* y i) (* t c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)));
double tmp;
if (z <= -3.35e+38) {
tmp = t_1;
} else if (z <= -6.6e-34) {
tmp = t * ((c * j) - (x * a));
} else if ((z <= -2.35e-111) || !(z <= 1.05e+68)) {
tmp = t_1;
} else {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)))
if (z <= (-3.35d+38)) then
tmp = t_1
else if (z <= (-6.6d-34)) then
tmp = t * ((c * j) - (x * a))
else if ((z <= (-2.35d-111)) .or. (.not. (z <= 1.05d+68))) then
tmp = t_1
else
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (x * (y * z)) + (b * ((a * i) - (z * c)));
double tmp;
if (z <= -3.35e+38) {
tmp = t_1;
} else if (z <= -6.6e-34) {
tmp = t * ((c * j) - (x * a));
} else if ((z <= -2.35e-111) || !(z <= 1.05e+68)) {
tmp = t_1;
} else {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (x * (y * z)) + (b * ((a * i) - (z * c))) tmp = 0 if z <= -3.35e+38: tmp = t_1 elif z <= -6.6e-34: tmp = t * ((c * j) - (x * a)) elif (z <= -2.35e-111) or not (z <= 1.05e+68): tmp = t_1 else: tmp = (b * (a * i)) - (j * ((y * i) - (t * c))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) tmp = 0.0 if (z <= -3.35e+38) tmp = t_1; elseif (z <= -6.6e-34) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif ((z <= -2.35e-111) || !(z <= 1.05e+68)) tmp = t_1; else tmp = Float64(Float64(b * Float64(a * i)) - Float64(j * Float64(Float64(y * i) - Float64(t * c)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (x * (y * z)) + (b * ((a * i) - (z * c))); tmp = 0.0; if (z <= -3.35e+38) tmp = t_1; elseif (z <= -6.6e-34) tmp = t * ((c * j) - (x * a)); elseif ((z <= -2.35e-111) || ~((z <= 1.05e+68))) tmp = t_1; else tmp = (b * (a * i)) - (j * ((y * i) - (t * c))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.35e+38], t$95$1, If[LessEqual[z, -6.6e-34], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -2.35e-111], N[Not[LessEqual[z, 1.05e+68]], $MachinePrecision]], t$95$1, N[(N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision] - N[(j * N[(N[(y * i), $MachinePrecision] - N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;z \leq -3.35 \cdot 10^{+38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -6.6 \cdot 10^{-34}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;z \leq -2.35 \cdot 10^{-111} \lor \neg \left(z \leq 1.05 \cdot 10^{+68}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right) - j \cdot \left(y \cdot i - t \cdot c\right)\\
\end{array}
\end{array}
if z < -3.35000000000000012e38 or -6.59999999999999965e-34 < z < -2.35000000000000003e-111 or 1.05e68 < z Initial program 70.7%
+-commutative70.7%
fma-def72.2%
*-commutative72.2%
*-commutative72.2%
*-commutative72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in j around 0 73.2%
Taylor expanded in y around inf 72.5%
*-commutative72.5%
Simplified72.5%
if -3.35000000000000012e38 < z < -6.59999999999999965e-34Initial program 72.4%
cancel-sign-sub72.4%
cancel-sign-sub-inv72.4%
*-commutative72.4%
*-commutative72.4%
remove-double-neg72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
add-cube-cbrt72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
Applied egg-rr72.4%
Taylor expanded in t around inf 67.9%
*-commutative67.9%
mul-1-neg67.9%
unsub-neg67.9%
Simplified67.9%
if -2.35000000000000003e-111 < z < 1.05e68Initial program 82.7%
cancel-sign-sub82.7%
cancel-sign-sub-inv82.7%
*-commutative82.7%
*-commutative82.7%
remove-double-neg82.7%
*-commutative82.7%
*-commutative82.7%
Simplified82.7%
Taylor expanded in i around inf 67.9%
associate-*r*68.8%
*-commutative68.8%
Simplified68.8%
Final simplification70.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= j -4e+53)
(- (* b (* a i)) (* j (- (* y i) (* t c))))
(if (<= j 1.32e+170)
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -4e+53) {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
} else if (j <= 1.32e+170) {
tmp = (x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)));
} else {
tmp = j * ((t * c) - (y * i));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (j <= (-4d+53)) then
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)))
else if (j <= 1.32d+170) then
tmp = (x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))
else
tmp = j * ((t * c) - (y * i))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -4e+53) {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
} else if (j <= 1.32e+170) {
tmp = (x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)));
} else {
tmp = j * ((t * c) - (y * i));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if j <= -4e+53: tmp = (b * (a * i)) - (j * ((y * i) - (t * c))) elif j <= 1.32e+170: tmp = (x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c))) else: tmp = j * ((t * c) - (y * i)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -4e+53) tmp = Float64(Float64(b * Float64(a * i)) - Float64(j * Float64(Float64(y * i) - Float64(t * c)))); elseif (j <= 1.32e+170) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (j <= -4e+53) tmp = (b * (a * i)) - (j * ((y * i) - (t * c))); elseif (j <= 1.32e+170) tmp = (x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c))); else tmp = j * ((t * c) - (y * i)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -4e+53], N[(N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision] - N[(j * N[(N[(y * i), $MachinePrecision] - N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.32e+170], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -4 \cdot 10^{+53}:\\
\;\;\;\;b \cdot \left(a \cdot i\right) - j \cdot \left(y \cdot i - t \cdot c\right)\\
\mathbf{elif}\;j \leq 1.32 \cdot 10^{+170}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\end{array}
\end{array}
if j < -4e53Initial program 79.6%
cancel-sign-sub79.6%
cancel-sign-sub-inv79.6%
*-commutative79.6%
*-commutative79.6%
remove-double-neg79.6%
*-commutative79.6%
*-commutative79.6%
Simplified79.6%
Taylor expanded in i around inf 76.9%
associate-*r*83.7%
*-commutative83.7%
Simplified83.7%
if -4e53 < j < 1.3199999999999999e170Initial program 76.2%
+-commutative76.2%
fma-def78.0%
*-commutative78.0%
*-commutative78.0%
*-commutative78.0%
*-commutative78.0%
Simplified78.0%
Taylor expanded in j around 0 72.3%
if 1.3199999999999999e170 < j Initial program 67.9%
cancel-sign-sub67.9%
cancel-sign-sub-inv67.9%
*-commutative67.9%
*-commutative67.9%
remove-double-neg67.9%
*-commutative67.9%
*-commutative67.9%
Simplified67.9%
Taylor expanded in j around inf 67.9%
Final simplification74.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* t (- (* c j) (* x a)))))
(if (<= t -2100000000000.0)
t_1
(if (<= t -5e-83)
(* a (- (* b i) (* x t)))
(if (<= t -6.5e-247)
(* x (* y z))
(if (<= t -1.55e-302)
(* i (* a b))
(if (<= t 5.5e-242)
(* y (* i (- j)))
(if (<= t 9.2e+122) (* c (- (* t j) (* z b))) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = t * ((c * j) - (x * a));
double tmp;
if (t <= -2100000000000.0) {
tmp = t_1;
} else if (t <= -5e-83) {
tmp = a * ((b * i) - (x * t));
} else if (t <= -6.5e-247) {
tmp = x * (y * z);
} else if (t <= -1.55e-302) {
tmp = i * (a * b);
} else if (t <= 5.5e-242) {
tmp = y * (i * -j);
} else if (t <= 9.2e+122) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = t * ((c * j) - (x * a))
if (t <= (-2100000000000.0d0)) then
tmp = t_1
else if (t <= (-5d-83)) then
tmp = a * ((b * i) - (x * t))
else if (t <= (-6.5d-247)) then
tmp = x * (y * z)
else if (t <= (-1.55d-302)) then
tmp = i * (a * b)
else if (t <= 5.5d-242) then
tmp = y * (i * -j)
else if (t <= 9.2d+122) then
tmp = c * ((t * j) - (z * b))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = t * ((c * j) - (x * a));
double tmp;
if (t <= -2100000000000.0) {
tmp = t_1;
} else if (t <= -5e-83) {
tmp = a * ((b * i) - (x * t));
} else if (t <= -6.5e-247) {
tmp = x * (y * z);
} else if (t <= -1.55e-302) {
tmp = i * (a * b);
} else if (t <= 5.5e-242) {
tmp = y * (i * -j);
} else if (t <= 9.2e+122) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = t * ((c * j) - (x * a)) tmp = 0 if t <= -2100000000000.0: tmp = t_1 elif t <= -5e-83: tmp = a * ((b * i) - (x * t)) elif t <= -6.5e-247: tmp = x * (y * z) elif t <= -1.55e-302: tmp = i * (a * b) elif t <= 5.5e-242: tmp = y * (i * -j) elif t <= 9.2e+122: tmp = c * ((t * j) - (z * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -2100000000000.0) tmp = t_1; elseif (t <= -5e-83) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (t <= -6.5e-247) tmp = Float64(x * Float64(y * z)); elseif (t <= -1.55e-302) tmp = Float64(i * Float64(a * b)); elseif (t <= 5.5e-242) tmp = Float64(y * Float64(i * Float64(-j))); elseif (t <= 9.2e+122) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -2100000000000.0) tmp = t_1; elseif (t <= -5e-83) tmp = a * ((b * i) - (x * t)); elseif (t <= -6.5e-247) tmp = x * (y * z); elseif (t <= -1.55e-302) tmp = i * (a * b); elseif (t <= 5.5e-242) tmp = y * (i * -j); elseif (t <= 9.2e+122) tmp = c * ((t * j) - (z * b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2100000000000.0], t$95$1, If[LessEqual[t, -5e-83], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -6.5e-247], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.55e-302], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.5e-242], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.2e+122], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -2100000000000:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -5 \cdot 10^{-83}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;t \leq -6.5 \cdot 10^{-247}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq -1.55 \cdot 10^{-302}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 5.5 \cdot 10^{-242}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{+122}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -2.1e12 or 9.2000000000000002e122 < t Initial program 62.6%
cancel-sign-sub62.6%
cancel-sign-sub-inv62.6%
*-commutative62.6%
*-commutative62.6%
remove-double-neg62.6%
*-commutative62.6%
*-commutative62.6%
Simplified62.6%
add-cube-cbrt62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
Applied egg-rr62.5%
Taylor expanded in t around inf 75.3%
*-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
Simplified75.3%
if -2.1e12 < t < -5e-83Initial program 78.4%
cancel-sign-sub78.4%
cancel-sign-sub-inv78.4%
*-commutative78.4%
*-commutative78.4%
remove-double-neg78.4%
*-commutative78.4%
*-commutative78.4%
Simplified78.4%
Taylor expanded in a around inf 41.1%
associate-*r*41.1%
neg-mul-141.1%
cancel-sign-sub41.1%
+-commutative41.1%
mul-1-neg41.1%
unsub-neg41.1%
*-commutative41.1%
Simplified41.1%
if -5e-83 < t < -6.4999999999999996e-247Initial program 97.1%
cancel-sign-sub97.1%
cancel-sign-sub-inv97.1%
*-commutative97.1%
*-commutative97.1%
remove-double-neg97.1%
*-commutative97.1%
*-commutative97.1%
Simplified97.1%
Taylor expanded in z around inf 69.5%
Taylor expanded in y around inf 40.4%
associate-*r*50.2%
Simplified50.2%
if -6.4999999999999996e-247 < t < -1.54999999999999992e-302Initial program 87.1%
cancel-sign-sub87.1%
cancel-sign-sub-inv87.1%
*-commutative87.1%
*-commutative87.1%
remove-double-neg87.1%
*-commutative87.1%
*-commutative87.1%
Simplified87.1%
Taylor expanded in a around inf 81.8%
associate-*r*81.8%
neg-mul-181.8%
cancel-sign-sub81.8%
+-commutative81.8%
mul-1-neg81.8%
unsub-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in b around inf 82.0%
if -1.54999999999999992e-302 < t < 5.4999999999999998e-242Initial program 85.1%
sub-neg85.1%
associate-+l+85.1%
fma-def85.1%
+-commutative85.1%
fma-def85.1%
*-commutative85.1%
*-commutative85.1%
distribute-rgt-neg-in85.1%
sub-neg85.1%
+-commutative85.1%
distribute-neg-in85.1%
unsub-neg85.1%
remove-double-neg85.1%
*-commutative85.1%
*-commutative85.1%
Simplified85.1%
Taylor expanded in y around inf 78.1%
Taylor expanded in z around 0 55.1%
neg-mul-155.1%
distribute-rgt-neg-in55.1%
Simplified55.1%
if 5.4999999999999998e-242 < t < 9.2000000000000002e122Initial program 79.0%
cancel-sign-sub79.0%
cancel-sign-sub-inv79.0%
*-commutative79.0%
*-commutative79.0%
remove-double-neg79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
Taylor expanded in c around inf 49.8%
Final simplification59.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -5400000000000.0)
t_2
(if (<= t -1.06e-89)
t_1
(if (<= t -3.9e-175)
(* x (* y z))
(if (<= t 1.25e-82)
t_1
(if (<= t 1.4e+122) (* c (- (* t j) (* z b))) t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -5400000000000.0) {
tmp = t_2;
} else if (t <= -1.06e-89) {
tmp = t_1;
} else if (t <= -3.9e-175) {
tmp = x * (y * z);
} else if (t <= 1.25e-82) {
tmp = t_1;
} else if (t <= 1.4e+122) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
t_2 = t * ((c * j) - (x * a))
if (t <= (-5400000000000.0d0)) then
tmp = t_2
else if (t <= (-1.06d-89)) then
tmp = t_1
else if (t <= (-3.9d-175)) then
tmp = x * (y * z)
else if (t <= 1.25d-82) then
tmp = t_1
else if (t <= 1.4d+122) then
tmp = c * ((t * j) - (z * b))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -5400000000000.0) {
tmp = t_2;
} else if (t <= -1.06e-89) {
tmp = t_1;
} else if (t <= -3.9e-175) {
tmp = x * (y * z);
} else if (t <= 1.25e-82) {
tmp = t_1;
} else if (t <= 1.4e+122) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) t_2 = t * ((c * j) - (x * a)) tmp = 0 if t <= -5400000000000.0: tmp = t_2 elif t <= -1.06e-89: tmp = t_1 elif t <= -3.9e-175: tmp = x * (y * z) elif t <= 1.25e-82: tmp = t_1 elif t <= 1.4e+122: tmp = c * ((t * j) - (z * b)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -5400000000000.0) tmp = t_2; elseif (t <= -1.06e-89) tmp = t_1; elseif (t <= -3.9e-175) tmp = Float64(x * Float64(y * z)); elseif (t <= 1.25e-82) tmp = t_1; elseif (t <= 1.4e+122) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); t_2 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -5400000000000.0) tmp = t_2; elseif (t <= -1.06e-89) tmp = t_1; elseif (t <= -3.9e-175) tmp = x * (y * z); elseif (t <= 1.25e-82) tmp = t_1; elseif (t <= 1.4e+122) tmp = c * ((t * j) - (z * b)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5400000000000.0], t$95$2, If[LessEqual[t, -1.06e-89], t$95$1, If[LessEqual[t, -3.9e-175], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e-82], t$95$1, If[LessEqual[t, 1.4e+122], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -5400000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.06 \cdot 10^{-89}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.9 \cdot 10^{-175}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-82}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.4 \cdot 10^{+122}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -5.4e12 or 1.4e122 < t Initial program 62.6%
cancel-sign-sub62.6%
cancel-sign-sub-inv62.6%
*-commutative62.6%
*-commutative62.6%
remove-double-neg62.6%
*-commutative62.6%
*-commutative62.6%
Simplified62.6%
add-cube-cbrt62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
*-commutative62.5%
Applied egg-rr62.5%
Taylor expanded in t around inf 75.3%
*-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
Simplified75.3%
if -5.4e12 < t < -1.0600000000000001e-89 or -3.89999999999999998e-175 < t < 1.25e-82Initial program 84.7%
cancel-sign-sub84.7%
cancel-sign-sub-inv84.7%
*-commutative84.7%
*-commutative84.7%
remove-double-neg84.7%
*-commutative84.7%
*-commutative84.7%
Simplified84.7%
Taylor expanded in b around inf 53.1%
if -1.0600000000000001e-89 < t < -3.89999999999999998e-175Initial program 99.9%
cancel-sign-sub99.9%
cancel-sign-sub-inv99.9%
*-commutative99.9%
*-commutative99.9%
remove-double-neg99.9%
*-commutative99.9%
*-commutative99.9%
Simplified99.9%
Taylor expanded in z around inf 60.5%
Taylor expanded in y around inf 46.9%
associate-*r*55.6%
Simplified55.6%
if 1.25e-82 < t < 1.4e122Initial program 73.3%
cancel-sign-sub73.3%
cancel-sign-sub-inv73.3%
*-commutative73.3%
*-commutative73.3%
remove-double-neg73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in c around inf 57.8%
Final simplification62.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))) (t_2 (* b (- (* a i) (* z c)))))
(if (<= b -3.8e+104)
t_2
(if (<= b 3.2e-302)
(* t (- (* c j) (* x a)))
(if (<= b 3.2e+59)
t_1
(if (<= b 1.9e+79) (* y (* x z)) (if (<= b 1e+102) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -3.8e+104) {
tmp = t_2;
} else if (b <= 3.2e-302) {
tmp = t * ((c * j) - (x * a));
} else if (b <= 3.2e+59) {
tmp = t_1;
} else if (b <= 1.9e+79) {
tmp = y * (x * z);
} else if (b <= 1e+102) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = j * ((t * c) - (y * i))
t_2 = b * ((a * i) - (z * c))
if (b <= (-3.8d+104)) then
tmp = t_2
else if (b <= 3.2d-302) then
tmp = t * ((c * j) - (x * a))
else if (b <= 3.2d+59) then
tmp = t_1
else if (b <= 1.9d+79) then
tmp = y * (x * z)
else if (b <= 1d+102) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -3.8e+104) {
tmp = t_2;
} else if (b <= 3.2e-302) {
tmp = t * ((c * j) - (x * a));
} else if (b <= 3.2e+59) {
tmp = t_1;
} else if (b <= 1.9e+79) {
tmp = y * (x * z);
} else if (b <= 1e+102) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) t_2 = b * ((a * i) - (z * c)) tmp = 0 if b <= -3.8e+104: tmp = t_2 elif b <= 3.2e-302: tmp = t * ((c * j) - (x * a)) elif b <= 3.2e+59: tmp = t_1 elif b <= 1.9e+79: tmp = y * (x * z) elif b <= 1e+102: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -3.8e+104) tmp = t_2; elseif (b <= 3.2e-302) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (b <= 3.2e+59) tmp = t_1; elseif (b <= 1.9e+79) tmp = Float64(y * Float64(x * z)); elseif (b <= 1e+102) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((t * c) - (y * i)); t_2 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -3.8e+104) tmp = t_2; elseif (b <= 3.2e-302) tmp = t * ((c * j) - (x * a)); elseif (b <= 3.2e+59) tmp = t_1; elseif (b <= 1.9e+79) tmp = y * (x * z); elseif (b <= 1e+102) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.8e+104], t$95$2, If[LessEqual[b, 3.2e-302], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.2e+59], t$95$1, If[LessEqual[b, 1.9e+79], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1e+102], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -3.8 \cdot 10^{+104}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{-302}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;b \leq 3.2 \cdot 10^{+59}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{+79}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;b \leq 10^{+102}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if b < -3.79999999999999969e104 or 9.99999999999999977e101 < b Initial program 76.1%
cancel-sign-sub76.1%
cancel-sign-sub-inv76.1%
*-commutative76.1%
*-commutative76.1%
remove-double-neg76.1%
*-commutative76.1%
*-commutative76.1%
Simplified76.1%
Taylor expanded in b around inf 72.3%
if -3.79999999999999969e104 < b < 3.19999999999999978e-302Initial program 69.4%
cancel-sign-sub69.4%
cancel-sign-sub-inv69.4%
*-commutative69.4%
*-commutative69.4%
remove-double-neg69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
add-cube-cbrt69.3%
*-commutative69.3%
*-commutative69.3%
*-commutative69.3%
*-commutative69.3%
*-commutative69.3%
*-commutative69.3%
Applied egg-rr69.3%
Taylor expanded in t around inf 60.3%
*-commutative60.3%
mul-1-neg60.3%
unsub-neg60.3%
Simplified60.3%
if 3.19999999999999978e-302 < b < 3.19999999999999982e59 or 1.9000000000000001e79 < b < 9.99999999999999977e101Initial program 79.4%
cancel-sign-sub79.4%
cancel-sign-sub-inv79.4%
*-commutative79.4%
*-commutative79.4%
remove-double-neg79.4%
*-commutative79.4%
*-commutative79.4%
Simplified79.4%
Taylor expanded in j around inf 55.8%
if 3.19999999999999982e59 < b < 1.9000000000000001e79Initial program 89.8%
sub-neg89.8%
associate-+l+89.8%
fma-def89.7%
+-commutative89.7%
fma-def89.7%
*-commutative89.7%
*-commutative89.7%
distribute-rgt-neg-in89.7%
sub-neg89.7%
+-commutative89.7%
distribute-neg-in89.7%
unsub-neg89.7%
remove-double-neg89.7%
*-commutative89.7%
*-commutative89.7%
Simplified89.7%
Taylor expanded in y around inf 61.1%
Taylor expanded in z around inf 61.1%
Final simplification62.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* t (- (* c j) (* x a)))) (t_2 (* z (- (* x y) (* b c)))))
(if (<= z -5e+41)
t_2
(if (<= z -3.2e-34)
t_1
(if (<= z 1.9e-134)
(* j (- (* t c) (* y i)))
(if (<= z 8.8e-82)
(* a (- (* b i) (* x t)))
(if (<= z 1.45e+68) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = t * ((c * j) - (x * a));
double t_2 = z * ((x * y) - (b * c));
double tmp;
if (z <= -5e+41) {
tmp = t_2;
} else if (z <= -3.2e-34) {
tmp = t_1;
} else if (z <= 1.9e-134) {
tmp = j * ((t * c) - (y * i));
} else if (z <= 8.8e-82) {
tmp = a * ((b * i) - (x * t));
} else if (z <= 1.45e+68) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = t * ((c * j) - (x * a))
t_2 = z * ((x * y) - (b * c))
if (z <= (-5d+41)) then
tmp = t_2
else if (z <= (-3.2d-34)) then
tmp = t_1
else if (z <= 1.9d-134) then
tmp = j * ((t * c) - (y * i))
else if (z <= 8.8d-82) then
tmp = a * ((b * i) - (x * t))
else if (z <= 1.45d+68) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = t * ((c * j) - (x * a));
double t_2 = z * ((x * y) - (b * c));
double tmp;
if (z <= -5e+41) {
tmp = t_2;
} else if (z <= -3.2e-34) {
tmp = t_1;
} else if (z <= 1.9e-134) {
tmp = j * ((t * c) - (y * i));
} else if (z <= 8.8e-82) {
tmp = a * ((b * i) - (x * t));
} else if (z <= 1.45e+68) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = t * ((c * j) - (x * a)) t_2 = z * ((x * y) - (b * c)) tmp = 0 if z <= -5e+41: tmp = t_2 elif z <= -3.2e-34: tmp = t_1 elif z <= 1.9e-134: tmp = j * ((t * c) - (y * i)) elif z <= 8.8e-82: tmp = a * ((b * i) - (x * t)) elif z <= 1.45e+68: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) t_2 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -5e+41) tmp = t_2; elseif (z <= -3.2e-34) tmp = t_1; elseif (z <= 1.9e-134) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (z <= 8.8e-82) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (z <= 1.45e+68) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = t * ((c * j) - (x * a)); t_2 = z * ((x * y) - (b * c)); tmp = 0.0; if (z <= -5e+41) tmp = t_2; elseif (z <= -3.2e-34) tmp = t_1; elseif (z <= 1.9e-134) tmp = j * ((t * c) - (y * i)); elseif (z <= 8.8e-82) tmp = a * ((b * i) - (x * t)); elseif (z <= 1.45e+68) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e+41], t$95$2, If[LessEqual[z, -3.2e-34], t$95$1, If[LessEqual[z, 1.9e-134], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.8e-82], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.45e+68], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j - x \cdot a\right)\\
t_2 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -5 \cdot 10^{+41}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -3.2 \cdot 10^{-34}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.9 \cdot 10^{-134}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;z \leq 8.8 \cdot 10^{-82}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{+68}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -5.00000000000000022e41 or 1.45000000000000006e68 < z Initial program 71.1%
cancel-sign-sub71.1%
cancel-sign-sub-inv71.1%
*-commutative71.1%
*-commutative71.1%
remove-double-neg71.1%
*-commutative71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in z around inf 72.8%
if -5.00000000000000022e41 < z < -3.20000000000000003e-34 or 8.79999999999999943e-82 < z < 1.45000000000000006e68Initial program 64.8%
cancel-sign-sub64.8%
cancel-sign-sub-inv64.8%
*-commutative64.8%
*-commutative64.8%
remove-double-neg64.8%
*-commutative64.8%
*-commutative64.8%
Simplified64.8%
add-cube-cbrt64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
Applied egg-rr64.7%
Taylor expanded in t around inf 63.1%
*-commutative63.1%
mul-1-neg63.1%
unsub-neg63.1%
Simplified63.1%
if -3.20000000000000003e-34 < z < 1.90000000000000001e-134Initial program 85.0%
cancel-sign-sub85.0%
cancel-sign-sub-inv85.0%
*-commutative85.0%
*-commutative85.0%
remove-double-neg85.0%
*-commutative85.0%
*-commutative85.0%
Simplified85.0%
Taylor expanded in j around inf 60.4%
if 1.90000000000000001e-134 < z < 8.79999999999999943e-82Initial program 85.7%
cancel-sign-sub85.7%
cancel-sign-sub-inv85.7%
*-commutative85.7%
*-commutative85.7%
remove-double-neg85.7%
*-commutative85.7%
*-commutative85.7%
Simplified85.7%
Taylor expanded in a around inf 58.5%
associate-*r*58.5%
neg-mul-158.5%
cancel-sign-sub58.5%
+-commutative58.5%
mul-1-neg58.5%
unsub-neg58.5%
*-commutative58.5%
Simplified58.5%
Final simplification65.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= z -2.8e+38) (not (<= z 1e+68))) (* z (- (* x y) (* b c))) (- (* b (* a i)) (* j (- (* y i) (* t c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -2.8e+38) || !(z <= 1e+68)) {
tmp = z * ((x * y) - (b * c));
} else {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((z <= (-2.8d+38)) .or. (.not. (z <= 1d+68))) then
tmp = z * ((x * y) - (b * c))
else
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -2.8e+38) || !(z <= 1e+68)) {
tmp = z * ((x * y) - (b * c));
} else {
tmp = (b * (a * i)) - (j * ((y * i) - (t * c)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (z <= -2.8e+38) or not (z <= 1e+68): tmp = z * ((x * y) - (b * c)) else: tmp = (b * (a * i)) - (j * ((y * i) - (t * c))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((z <= -2.8e+38) || !(z <= 1e+68)) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); else tmp = Float64(Float64(b * Float64(a * i)) - Float64(j * Float64(Float64(y * i) - Float64(t * c)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((z <= -2.8e+38) || ~((z <= 1e+68))) tmp = z * ((x * y) - (b * c)); else tmp = (b * (a * i)) - (j * ((y * i) - (t * c))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[z, -2.8e+38], N[Not[LessEqual[z, 1e+68]], $MachinePrecision]], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision] - N[(j * N[(N[(y * i), $MachinePrecision] - N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.8 \cdot 10^{+38} \lor \neg \left(z \leq 10^{+68}\right):\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right) - j \cdot \left(y \cdot i - t \cdot c\right)\\
\end{array}
\end{array}
if z < -2.8e38 or 9.99999999999999953e67 < z Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in z around inf 72.2%
if -2.8e38 < z < 9.99999999999999953e67Initial program 79.3%
cancel-sign-sub79.3%
cancel-sign-sub-inv79.3%
*-commutative79.3%
*-commutative79.3%
remove-double-neg79.3%
*-commutative79.3%
*-commutative79.3%
Simplified79.3%
Taylor expanded in i around inf 62.1%
associate-*r*62.0%
*-commutative62.0%
Simplified62.0%
Final simplification66.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t)))))
(if (<= a -4.4e-74)
t_1
(if (<= a 6.8e-248)
(* z (* x y))
(if (<= a 2.8e-98)
(* b (* c (- z)))
(if (<= a 2.7e+42) (* t (* c j)) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double tmp;
if (a <= -4.4e-74) {
tmp = t_1;
} else if (a <= 6.8e-248) {
tmp = z * (x * y);
} else if (a <= 2.8e-98) {
tmp = b * (c * -z);
} else if (a <= 2.7e+42) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = a * ((b * i) - (x * t))
if (a <= (-4.4d-74)) then
tmp = t_1
else if (a <= 6.8d-248) then
tmp = z * (x * y)
else if (a <= 2.8d-98) then
tmp = b * (c * -z)
else if (a <= 2.7d+42) then
tmp = t * (c * j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double tmp;
if (a <= -4.4e-74) {
tmp = t_1;
} else if (a <= 6.8e-248) {
tmp = z * (x * y);
} else if (a <= 2.8e-98) {
tmp = b * (c * -z);
} else if (a <= 2.7e+42) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) tmp = 0 if a <= -4.4e-74: tmp = t_1 elif a <= 6.8e-248: tmp = z * (x * y) elif a <= 2.8e-98: tmp = b * (c * -z) elif a <= 2.7e+42: tmp = t * (c * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) tmp = 0.0 if (a <= -4.4e-74) tmp = t_1; elseif (a <= 6.8e-248) tmp = Float64(z * Float64(x * y)); elseif (a <= 2.8e-98) tmp = Float64(b * Float64(c * Float64(-z))); elseif (a <= 2.7e+42) tmp = Float64(t * Float64(c * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); tmp = 0.0; if (a <= -4.4e-74) tmp = t_1; elseif (a <= 6.8e-248) tmp = z * (x * y); elseif (a <= 2.8e-98) tmp = b * (c * -z); elseif (a <= 2.7e+42) tmp = t * (c * j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.4e-74], t$95$1, If[LessEqual[a, 6.8e-248], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e-98], N[(b * N[(c * (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.7e+42], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{if}\;a \leq -4.4 \cdot 10^{-74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;a \leq 6.8 \cdot 10^{-248}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{-98}:\\
\;\;\;\;b \cdot \left(c \cdot \left(-z\right)\right)\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{+42}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if a < -4.40000000000000021e-74 or 2.7000000000000001e42 < a Initial program 67.2%
cancel-sign-sub67.2%
cancel-sign-sub-inv67.2%
*-commutative67.2%
*-commutative67.2%
remove-double-neg67.2%
*-commutative67.2%
*-commutative67.2%
Simplified67.2%
Taylor expanded in a around inf 53.6%
associate-*r*53.6%
neg-mul-153.6%
cancel-sign-sub53.6%
+-commutative53.6%
mul-1-neg53.6%
unsub-neg53.6%
*-commutative53.6%
Simplified53.6%
if -4.40000000000000021e-74 < a < 6.7999999999999996e-248Initial program 91.2%
cancel-sign-sub91.2%
cancel-sign-sub-inv91.2%
*-commutative91.2%
*-commutative91.2%
remove-double-neg91.2%
*-commutative91.2%
*-commutative91.2%
Simplified91.2%
Taylor expanded in z around inf 51.8%
Taylor expanded in y around inf 40.7%
if 6.7999999999999996e-248 < a < 2.7999999999999999e-98Initial program 85.4%
cancel-sign-sub85.4%
cancel-sign-sub-inv85.4%
*-commutative85.4%
*-commutative85.4%
remove-double-neg85.4%
*-commutative85.4%
*-commutative85.4%
Simplified85.4%
Taylor expanded in z around inf 51.9%
Taylor expanded in y around 0 37.0%
mul-1-neg37.0%
associate-*r*42.6%
distribute-lft-neg-in42.6%
*-commutative42.6%
Simplified42.6%
if 2.7999999999999999e-98 < a < 2.7000000000000001e42Initial program 75.1%
cancel-sign-sub75.1%
cancel-sign-sub-inv75.1%
*-commutative75.1%
*-commutative75.1%
remove-double-neg75.1%
*-commutative75.1%
*-commutative75.1%
Simplified75.1%
add-cube-cbrt75.0%
*-commutative75.0%
*-commutative75.0%
*-commutative75.0%
*-commutative75.0%
*-commutative75.0%
*-commutative75.0%
Applied egg-rr75.0%
Taylor expanded in t around inf 56.6%
*-commutative56.6%
mul-1-neg56.6%
unsub-neg56.6%
Simplified56.6%
Taylor expanded in c around inf 51.4%
Final simplification49.0%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= t -4.2e+80)
(* t (* c j))
(if (<= t -3.6e-249)
(* x (* y z))
(if (<= t -1.45e-301)
(* i (* a b))
(if (<= t 1.25e-243)
(* i (* y (- j)))
(if (<= t 4.9e+122) (* c (* b (- z))) (* c (* t j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (t <= -4.2e+80) {
tmp = t * (c * j);
} else if (t <= -3.6e-249) {
tmp = x * (y * z);
} else if (t <= -1.45e-301) {
tmp = i * (a * b);
} else if (t <= 1.25e-243) {
tmp = i * (y * -j);
} else if (t <= 4.9e+122) {
tmp = c * (b * -z);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (t <= (-4.2d+80)) then
tmp = t * (c * j)
else if (t <= (-3.6d-249)) then
tmp = x * (y * z)
else if (t <= (-1.45d-301)) then
tmp = i * (a * b)
else if (t <= 1.25d-243) then
tmp = i * (y * -j)
else if (t <= 4.9d+122) then
tmp = c * (b * -z)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (t <= -4.2e+80) {
tmp = t * (c * j);
} else if (t <= -3.6e-249) {
tmp = x * (y * z);
} else if (t <= -1.45e-301) {
tmp = i * (a * b);
} else if (t <= 1.25e-243) {
tmp = i * (y * -j);
} else if (t <= 4.9e+122) {
tmp = c * (b * -z);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if t <= -4.2e+80: tmp = t * (c * j) elif t <= -3.6e-249: tmp = x * (y * z) elif t <= -1.45e-301: tmp = i * (a * b) elif t <= 1.25e-243: tmp = i * (y * -j) elif t <= 4.9e+122: tmp = c * (b * -z) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (t <= -4.2e+80) tmp = Float64(t * Float64(c * j)); elseif (t <= -3.6e-249) tmp = Float64(x * Float64(y * z)); elseif (t <= -1.45e-301) tmp = Float64(i * Float64(a * b)); elseif (t <= 1.25e-243) tmp = Float64(i * Float64(y * Float64(-j))); elseif (t <= 4.9e+122) tmp = Float64(c * Float64(b * Float64(-z))); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (t <= -4.2e+80) tmp = t * (c * j); elseif (t <= -3.6e-249) tmp = x * (y * z); elseif (t <= -1.45e-301) tmp = i * (a * b); elseif (t <= 1.25e-243) tmp = i * (y * -j); elseif (t <= 4.9e+122) tmp = c * (b * -z); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[t, -4.2e+80], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.6e-249], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.45e-301], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e-243], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.9e+122], N[(c * N[(b * (-z)), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -4.2 \cdot 10^{+80}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;t \leq -3.6 \cdot 10^{-249}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq -1.45 \cdot 10^{-301}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{-243}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{elif}\;t \leq 4.9 \cdot 10^{+122}:\\
\;\;\;\;c \cdot \left(b \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if t < -4.20000000000000003e80Initial program 66.5%
cancel-sign-sub66.5%
cancel-sign-sub-inv66.5%
*-commutative66.5%
*-commutative66.5%
remove-double-neg66.5%
*-commutative66.5%
*-commutative66.5%
Simplified66.5%
add-cube-cbrt66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
Applied egg-rr66.3%
Taylor expanded in t around inf 73.6%
*-commutative73.6%
mul-1-neg73.6%
unsub-neg73.6%
Simplified73.6%
Taylor expanded in c around inf 47.0%
if -4.20000000000000003e80 < t < -3.59999999999999995e-249Initial program 86.8%
cancel-sign-sub86.8%
cancel-sign-sub-inv86.8%
*-commutative86.8%
*-commutative86.8%
remove-double-neg86.8%
*-commutative86.8%
*-commutative86.8%
Simplified86.8%
Taylor expanded in z around inf 58.6%
Taylor expanded in y around inf 34.3%
associate-*r*38.0%
Simplified38.0%
if -3.59999999999999995e-249 < t < -1.44999999999999992e-301Initial program 87.1%
cancel-sign-sub87.1%
cancel-sign-sub-inv87.1%
*-commutative87.1%
*-commutative87.1%
remove-double-neg87.1%
*-commutative87.1%
*-commutative87.1%
Simplified87.1%
Taylor expanded in a around inf 81.8%
associate-*r*81.8%
neg-mul-181.8%
cancel-sign-sub81.8%
+-commutative81.8%
mul-1-neg81.8%
unsub-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in b around inf 82.0%
if -1.44999999999999992e-301 < t < 1.25e-243Initial program 85.1%
sub-neg85.1%
associate-+l+85.1%
fma-def85.1%
+-commutative85.1%
fma-def85.1%
*-commutative85.1%
*-commutative85.1%
distribute-rgt-neg-in85.1%
sub-neg85.1%
+-commutative85.1%
distribute-neg-in85.1%
unsub-neg85.1%
remove-double-neg85.1%
*-commutative85.1%
*-commutative85.1%
Simplified85.1%
Taylor expanded in y around inf 78.1%
Taylor expanded in z around 0 55.1%
associate-*r*55.1%
*-commutative55.1%
associate-*r*55.0%
associate-*r*55.0%
neg-mul-155.0%
Simplified55.0%
if 1.25e-243 < t < 4.8999999999999998e122Initial program 79.0%
cancel-sign-sub79.0%
cancel-sign-sub-inv79.0%
*-commutative79.0%
*-commutative79.0%
remove-double-neg79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
add-cube-cbrt79.0%
*-commutative79.0%
*-commutative79.0%
*-commutative79.0%
*-commutative79.0%
*-commutative79.0%
*-commutative79.0%
Applied egg-rr79.0%
Taylor expanded in z around inf 72.2%
Taylor expanded in b around inf 36.5%
mul-1-neg36.5%
*-commutative36.5%
Simplified36.5%
if 4.8999999999999998e122 < t Initial program 57.0%
cancel-sign-sub57.0%
cancel-sign-sub-inv57.0%
*-commutative57.0%
*-commutative57.0%
remove-double-neg57.0%
*-commutative57.0%
*-commutative57.0%
Simplified57.0%
add-cube-cbrt57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
Applied egg-rr57.0%
Taylor expanded in t around inf 84.1%
*-commutative84.1%
mul-1-neg84.1%
unsub-neg84.1%
Simplified84.1%
Taylor expanded in c around inf 51.9%
Final simplification43.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= t -6.8e+80)
(* t (* c j))
(if (<= t -4.7e-243)
(* x (* y z))
(if (<= t -1.15e-300)
(* i (* a b))
(if (<= t 9.2e-158)
(* y (* i (- j)))
(if (<= t 1.85e+122) (* c (* b (- z))) (* c (* t j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (t <= -6.8e+80) {
tmp = t * (c * j);
} else if (t <= -4.7e-243) {
tmp = x * (y * z);
} else if (t <= -1.15e-300) {
tmp = i * (a * b);
} else if (t <= 9.2e-158) {
tmp = y * (i * -j);
} else if (t <= 1.85e+122) {
tmp = c * (b * -z);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (t <= (-6.8d+80)) then
tmp = t * (c * j)
else if (t <= (-4.7d-243)) then
tmp = x * (y * z)
else if (t <= (-1.15d-300)) then
tmp = i * (a * b)
else if (t <= 9.2d-158) then
tmp = y * (i * -j)
else if (t <= 1.85d+122) then
tmp = c * (b * -z)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (t <= -6.8e+80) {
tmp = t * (c * j);
} else if (t <= -4.7e-243) {
tmp = x * (y * z);
} else if (t <= -1.15e-300) {
tmp = i * (a * b);
} else if (t <= 9.2e-158) {
tmp = y * (i * -j);
} else if (t <= 1.85e+122) {
tmp = c * (b * -z);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if t <= -6.8e+80: tmp = t * (c * j) elif t <= -4.7e-243: tmp = x * (y * z) elif t <= -1.15e-300: tmp = i * (a * b) elif t <= 9.2e-158: tmp = y * (i * -j) elif t <= 1.85e+122: tmp = c * (b * -z) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (t <= -6.8e+80) tmp = Float64(t * Float64(c * j)); elseif (t <= -4.7e-243) tmp = Float64(x * Float64(y * z)); elseif (t <= -1.15e-300) tmp = Float64(i * Float64(a * b)); elseif (t <= 9.2e-158) tmp = Float64(y * Float64(i * Float64(-j))); elseif (t <= 1.85e+122) tmp = Float64(c * Float64(b * Float64(-z))); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (t <= -6.8e+80) tmp = t * (c * j); elseif (t <= -4.7e-243) tmp = x * (y * z); elseif (t <= -1.15e-300) tmp = i * (a * b); elseif (t <= 9.2e-158) tmp = y * (i * -j); elseif (t <= 1.85e+122) tmp = c * (b * -z); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[t, -6.8e+80], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -4.7e-243], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.15e-300], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.2e-158], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.85e+122], N[(c * N[(b * (-z)), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -6.8 \cdot 10^{+80}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;t \leq -4.7 \cdot 10^{-243}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{-300}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 9.2 \cdot 10^{-158}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;t \leq 1.85 \cdot 10^{+122}:\\
\;\;\;\;c \cdot \left(b \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if t < -6.79999999999999984e80Initial program 66.5%
cancel-sign-sub66.5%
cancel-sign-sub-inv66.5%
*-commutative66.5%
*-commutative66.5%
remove-double-neg66.5%
*-commutative66.5%
*-commutative66.5%
Simplified66.5%
add-cube-cbrt66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
*-commutative66.3%
Applied egg-rr66.3%
Taylor expanded in t around inf 73.6%
*-commutative73.6%
mul-1-neg73.6%
unsub-neg73.6%
Simplified73.6%
Taylor expanded in c around inf 47.0%
if -6.79999999999999984e80 < t < -4.7000000000000004e-243Initial program 86.8%
cancel-sign-sub86.8%
cancel-sign-sub-inv86.8%
*-commutative86.8%
*-commutative86.8%
remove-double-neg86.8%
*-commutative86.8%
*-commutative86.8%
Simplified86.8%
Taylor expanded in z around inf 58.6%
Taylor expanded in y around inf 34.3%
associate-*r*38.0%
Simplified38.0%
if -4.7000000000000004e-243 < t < -1.15e-300Initial program 87.1%
cancel-sign-sub87.1%
cancel-sign-sub-inv87.1%
*-commutative87.1%
*-commutative87.1%
remove-double-neg87.1%
*-commutative87.1%
*-commutative87.1%
Simplified87.1%
Taylor expanded in a around inf 81.8%
associate-*r*81.8%
neg-mul-181.8%
cancel-sign-sub81.8%
+-commutative81.8%
mul-1-neg81.8%
unsub-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in b around inf 82.0%
if -1.15e-300 < t < 9.1999999999999995e-158Initial program 80.1%
sub-neg80.1%
associate-+l+80.1%
fma-def83.4%
+-commutative83.4%
fma-def83.4%
*-commutative83.4%
*-commutative83.4%
distribute-rgt-neg-in83.4%
sub-neg83.4%
+-commutative83.4%
distribute-neg-in83.4%
unsub-neg83.4%
remove-double-neg83.4%
*-commutative83.4%
*-commutative83.4%
Simplified83.4%
Taylor expanded in y around inf 58.3%
Taylor expanded in z around 0 41.7%
neg-mul-141.7%
distribute-rgt-neg-in41.7%
Simplified41.7%
if 9.1999999999999995e-158 < t < 1.8499999999999998e122Initial program 79.8%
cancel-sign-sub79.8%
cancel-sign-sub-inv79.8%
*-commutative79.8%
*-commutative79.8%
remove-double-neg79.8%
*-commutative79.8%
*-commutative79.8%
Simplified79.8%
add-cube-cbrt79.7%
*-commutative79.7%
*-commutative79.7%
*-commutative79.7%
*-commutative79.7%
*-commutative79.7%
*-commutative79.7%
Applied egg-rr79.7%
Taylor expanded in z around inf 69.6%
Taylor expanded in b around inf 38.0%
mul-1-neg38.0%
*-commutative38.0%
Simplified38.0%
if 1.8499999999999998e122 < t Initial program 57.0%
cancel-sign-sub57.0%
cancel-sign-sub-inv57.0%
*-commutative57.0%
*-commutative57.0%
remove-double-neg57.0%
*-commutative57.0%
*-commutative57.0%
Simplified57.0%
add-cube-cbrt57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
*-commutative57.0%
Applied egg-rr57.0%
Taylor expanded in t around inf 84.1%
*-commutative84.1%
mul-1-neg84.1%
unsub-neg84.1%
Simplified84.1%
Taylor expanded in c around inf 51.9%
Final simplification43.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -3.5e+265)
(* t (* x (- a)))
(if (<= x -2.1e+80)
(* z (* x y))
(if (<= x 6.2e+83) (* c (- (* t j) (* z b))) (* a (- (* b i) (* x t)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.5e+265) {
tmp = t * (x * -a);
} else if (x <= -2.1e+80) {
tmp = z * (x * y);
} else if (x <= 6.2e+83) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-3.5d+265)) then
tmp = t * (x * -a)
else if (x <= (-2.1d+80)) then
tmp = z * (x * y)
else if (x <= 6.2d+83) then
tmp = c * ((t * j) - (z * b))
else
tmp = a * ((b * i) - (x * t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.5e+265) {
tmp = t * (x * -a);
} else if (x <= -2.1e+80) {
tmp = z * (x * y);
} else if (x <= 6.2e+83) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -3.5e+265: tmp = t * (x * -a) elif x <= -2.1e+80: tmp = z * (x * y) elif x <= 6.2e+83: tmp = c * ((t * j) - (z * b)) else: tmp = a * ((b * i) - (x * t)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -3.5e+265) tmp = Float64(t * Float64(x * Float64(-a))); elseif (x <= -2.1e+80) tmp = Float64(z * Float64(x * y)); elseif (x <= 6.2e+83) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -3.5e+265) tmp = t * (x * -a); elseif (x <= -2.1e+80) tmp = z * (x * y); elseif (x <= 6.2e+83) tmp = c * ((t * j) - (z * b)); else tmp = a * ((b * i) - (x * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -3.5e+265], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.1e+80], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.2e+83], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.5 \cdot 10^{+265}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;x \leq -2.1 \cdot 10^{+80}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;x \leq 6.2 \cdot 10^{+83}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\end{array}
\end{array}
if x < -3.5e265Initial program 76.9%
cancel-sign-sub76.9%
cancel-sign-sub-inv76.9%
*-commutative76.9%
*-commutative76.9%
remove-double-neg76.9%
*-commutative76.9%
*-commutative76.9%
Simplified76.9%
add-cube-cbrt76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
Applied egg-rr76.9%
Taylor expanded in t around inf 62.2%
*-commutative62.2%
mul-1-neg62.2%
unsub-neg62.2%
Simplified62.2%
Taylor expanded in c around 0 62.3%
*-commutative62.3%
associate-*r*62.3%
neg-mul-162.3%
Simplified62.3%
if -3.5e265 < x < -2.10000000000000001e80Initial program 64.4%
cancel-sign-sub64.4%
cancel-sign-sub-inv64.4%
*-commutative64.4%
*-commutative64.4%
remove-double-neg64.4%
*-commutative64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in z around inf 68.1%
Taylor expanded in y around inf 57.6%
if -2.10000000000000001e80 < x < 6.19999999999999984e83Initial program 80.0%
cancel-sign-sub80.0%
cancel-sign-sub-inv80.0%
*-commutative80.0%
*-commutative80.0%
remove-double-neg80.0%
*-commutative80.0%
*-commutative80.0%
Simplified80.0%
Taylor expanded in c around inf 53.7%
if 6.19999999999999984e83 < x Initial program 69.9%
cancel-sign-sub69.9%
cancel-sign-sub-inv69.9%
*-commutative69.9%
*-commutative69.9%
remove-double-neg69.9%
*-commutative69.9%
*-commutative69.9%
Simplified69.9%
Taylor expanded in a around inf 51.9%
associate-*r*51.9%
neg-mul-151.9%
cancel-sign-sub51.9%
+-commutative51.9%
mul-1-neg51.9%
unsub-neg51.9%
*-commutative51.9%
Simplified51.9%
Final simplification54.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -1.95e+80)
t_1
(if (<= x 4.9e-98)
(* c (- (* t j) (* z b)))
(if (<= x 2.7e+66) (* j (- (* t c) (* y i))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.95e+80) {
tmp = t_1;
} else if (x <= 4.9e-98) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 2.7e+66) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if (x <= (-1.95d+80)) then
tmp = t_1
else if (x <= 4.9d-98) then
tmp = c * ((t * j) - (z * b))
else if (x <= 2.7d+66) then
tmp = j * ((t * c) - (y * i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.95e+80) {
tmp = t_1;
} else if (x <= 4.9e-98) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 2.7e+66) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if x <= -1.95e+80: tmp = t_1 elif x <= 4.9e-98: tmp = c * ((t * j) - (z * b)) elif x <= 2.7e+66: tmp = j * ((t * c) - (y * i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -1.95e+80) tmp = t_1; elseif (x <= 4.9e-98) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (x <= 2.7e+66) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -1.95e+80) tmp = t_1; elseif (x <= 4.9e-98) tmp = c * ((t * j) - (z * b)); elseif (x <= 2.7e+66) tmp = j * ((t * c) - (y * i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.95e+80], t$95$1, If[LessEqual[x, 4.9e-98], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.7e+66], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -1.95 \cdot 10^{+80}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 4.9 \cdot 10^{-98}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{+66}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -1.94999999999999999e80 or 2.7e66 < x Initial program 69.4%
cancel-sign-sub69.4%
cancel-sign-sub-inv69.4%
*-commutative69.4%
*-commutative69.4%
remove-double-neg69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
Taylor expanded in x around inf 71.7%
if -1.94999999999999999e80 < x < 4.90000000000000014e-98Initial program 76.6%
cancel-sign-sub76.6%
cancel-sign-sub-inv76.6%
*-commutative76.6%
*-commutative76.6%
remove-double-neg76.6%
*-commutative76.6%
*-commutative76.6%
Simplified76.6%
Taylor expanded in c around inf 56.0%
if 4.90000000000000014e-98 < x < 2.7e66Initial program 90.0%
cancel-sign-sub90.0%
cancel-sign-sub-inv90.0%
*-commutative90.0%
*-commutative90.0%
remove-double-neg90.0%
*-commutative90.0%
*-commutative90.0%
Simplified90.0%
Taylor expanded in j around inf 65.0%
Final simplification63.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (* x y))))
(if (<= z -2.6e+38)
t_1
(if (<= z 1.35e-138)
(* c (* t j))
(if (<= z 1.05e+86) (* i (* a b)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * (x * y);
double tmp;
if (z <= -2.6e+38) {
tmp = t_1;
} else if (z <= 1.35e-138) {
tmp = c * (t * j);
} else if (z <= 1.05e+86) {
tmp = i * (a * b);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = z * (x * y)
if (z <= (-2.6d+38)) then
tmp = t_1
else if (z <= 1.35d-138) then
tmp = c * (t * j)
else if (z <= 1.05d+86) then
tmp = i * (a * b)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * (x * y);
double tmp;
if (z <= -2.6e+38) {
tmp = t_1;
} else if (z <= 1.35e-138) {
tmp = c * (t * j);
} else if (z <= 1.05e+86) {
tmp = i * (a * b);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if z <= -2.6e+38: tmp = t_1 elif z <= 1.35e-138: tmp = c * (t * j) elif z <= 1.05e+86: tmp = i * (a * b) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (z <= -2.6e+38) tmp = t_1; elseif (z <= 1.35e-138) tmp = Float64(c * Float64(t * j)); elseif (z <= 1.05e+86) tmp = Float64(i * Float64(a * b)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (z <= -2.6e+38) tmp = t_1; elseif (z <= 1.35e-138) tmp = c * (t * j); elseif (z <= 1.05e+86) tmp = i * (a * b); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.6e+38], t$95$1, If[LessEqual[z, 1.35e-138], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.05e+86], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;z \leq -2.6 \cdot 10^{+38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 1.35 \cdot 10^{-138}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{+86}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -2.5999999999999999e38 or 1.0499999999999999e86 < z Initial program 72.2%
cancel-sign-sub72.2%
cancel-sign-sub-inv72.2%
*-commutative72.2%
*-commutative72.2%
remove-double-neg72.2%
*-commutative72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in z around inf 72.9%
Taylor expanded in y around inf 43.9%
if -2.5999999999999999e38 < z < 1.35000000000000014e-138Initial program 82.5%
cancel-sign-sub82.5%
cancel-sign-sub-inv82.5%
*-commutative82.5%
*-commutative82.5%
remove-double-neg82.5%
*-commutative82.5%
*-commutative82.5%
Simplified82.5%
add-cube-cbrt82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
Applied egg-rr82.4%
Taylor expanded in t around inf 48.5%
*-commutative48.5%
mul-1-neg48.5%
unsub-neg48.5%
Simplified48.5%
Taylor expanded in c around inf 34.9%
if 1.35000000000000014e-138 < z < 1.0499999999999999e86Initial program 68.6%
cancel-sign-sub68.6%
cancel-sign-sub-inv68.6%
*-commutative68.6%
*-commutative68.6%
remove-double-neg68.6%
*-commutative68.6%
*-commutative68.6%
Simplified68.6%
Taylor expanded in a around inf 50.6%
associate-*r*50.6%
neg-mul-150.6%
cancel-sign-sub50.6%
+-commutative50.6%
mul-1-neg50.6%
unsub-neg50.6%
*-commutative50.6%
Simplified50.6%
Taylor expanded in b around inf 35.1%
Final simplification38.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -2.7e+38)
(* x (* y z))
(if (<= z 9e-140)
(* c (* t j))
(if (<= z 2.5e+77) (* i (* a b)) (* z (* x y))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.7e+38) {
tmp = x * (y * z);
} else if (z <= 9e-140) {
tmp = c * (t * j);
} else if (z <= 2.5e+77) {
tmp = i * (a * b);
} else {
tmp = z * (x * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-2.7d+38)) then
tmp = x * (y * z)
else if (z <= 9d-140) then
tmp = c * (t * j)
else if (z <= 2.5d+77) then
tmp = i * (a * b)
else
tmp = z * (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 tmp;
if (z <= -2.7e+38) {
tmp = x * (y * z);
} else if (z <= 9e-140) {
tmp = c * (t * j);
} else if (z <= 2.5e+77) {
tmp = i * (a * b);
} else {
tmp = z * (x * y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.7e+38: tmp = x * (y * z) elif z <= 9e-140: tmp = c * (t * j) elif z <= 2.5e+77: tmp = i * (a * b) else: tmp = z * (x * y) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.7e+38) tmp = Float64(x * Float64(y * z)); elseif (z <= 9e-140) tmp = Float64(c * Float64(t * j)); elseif (z <= 2.5e+77) tmp = Float64(i * Float64(a * b)); else tmp = Float64(z * Float64(x * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.7e+38) tmp = x * (y * z); elseif (z <= 9e-140) tmp = c * (t * j); elseif (z <= 2.5e+77) tmp = i * (a * b); else tmp = z * (x * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.7e+38], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 9e-140], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.5e+77], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.7 \cdot 10^{+38}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;z \leq 9 \cdot 10^{-140}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;z \leq 2.5 \cdot 10^{+77}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\end{array}
\end{array}
if z < -2.69999999999999996e38Initial program 73.4%
cancel-sign-sub73.4%
cancel-sign-sub-inv73.4%
*-commutative73.4%
*-commutative73.4%
remove-double-neg73.4%
*-commutative73.4%
*-commutative73.4%
Simplified73.4%
Taylor expanded in z around inf 71.3%
Taylor expanded in y around inf 37.7%
associate-*r*39.6%
Simplified39.6%
if -2.69999999999999996e38 < z < 9.00000000000000008e-140Initial program 82.5%
cancel-sign-sub82.5%
cancel-sign-sub-inv82.5%
*-commutative82.5%
*-commutative82.5%
remove-double-neg82.5%
*-commutative82.5%
*-commutative82.5%
Simplified82.5%
add-cube-cbrt82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
Applied egg-rr82.4%
Taylor expanded in t around inf 48.5%
*-commutative48.5%
mul-1-neg48.5%
unsub-neg48.5%
Simplified48.5%
Taylor expanded in c around inf 34.9%
if 9.00000000000000008e-140 < z < 2.50000000000000002e77Initial program 68.6%
cancel-sign-sub68.6%
cancel-sign-sub-inv68.6%
*-commutative68.6%
*-commutative68.6%
remove-double-neg68.6%
*-commutative68.6%
*-commutative68.6%
Simplified68.6%
Taylor expanded in a around inf 50.6%
associate-*r*50.6%
neg-mul-150.6%
cancel-sign-sub50.6%
+-commutative50.6%
mul-1-neg50.6%
unsub-neg50.6%
*-commutative50.6%
Simplified50.6%
Taylor expanded in b around inf 35.1%
if 2.50000000000000002e77 < z Initial program 71.1%
cancel-sign-sub71.1%
cancel-sign-sub-inv71.1%
*-commutative71.1%
*-commutative71.1%
remove-double-neg71.1%
*-commutative71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in z around inf 74.5%
Taylor expanded in y around inf 50.3%
Final simplification38.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -3.1e+38)
(* x (* y z))
(if (<= z 5.2e-139)
(* c (* t j))
(if (<= z 1.25e+82) (* i (* a b)) (* y (* x z))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -3.1e+38) {
tmp = x * (y * z);
} else if (z <= 5.2e-139) {
tmp = c * (t * j);
} else if (z <= 1.25e+82) {
tmp = i * (a * b);
} else {
tmp = y * (x * z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-3.1d+38)) then
tmp = x * (y * z)
else if (z <= 5.2d-139) then
tmp = c * (t * j)
else if (z <= 1.25d+82) then
tmp = i * (a * b)
else
tmp = y * (x * z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -3.1e+38) {
tmp = x * (y * z);
} else if (z <= 5.2e-139) {
tmp = c * (t * j);
} else if (z <= 1.25e+82) {
tmp = i * (a * b);
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -3.1e+38: tmp = x * (y * z) elif z <= 5.2e-139: tmp = c * (t * j) elif z <= 1.25e+82: tmp = i * (a * b) else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -3.1e+38) tmp = Float64(x * Float64(y * z)); elseif (z <= 5.2e-139) tmp = Float64(c * Float64(t * j)); elseif (z <= 1.25e+82) tmp = Float64(i * Float64(a * b)); else tmp = Float64(y * Float64(x * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -3.1e+38) tmp = x * (y * z); elseif (z <= 5.2e-139) tmp = c * (t * j); elseif (z <= 1.25e+82) tmp = i * (a * b); else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -3.1e+38], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e-139], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.25e+82], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.1 \cdot 10^{+38}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{-139}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{+82}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if z < -3.10000000000000018e38Initial program 73.4%
cancel-sign-sub73.4%
cancel-sign-sub-inv73.4%
*-commutative73.4%
*-commutative73.4%
remove-double-neg73.4%
*-commutative73.4%
*-commutative73.4%
Simplified73.4%
Taylor expanded in z around inf 71.3%
Taylor expanded in y around inf 37.7%
associate-*r*39.6%
Simplified39.6%
if -3.10000000000000018e38 < z < 5.1999999999999996e-139Initial program 82.5%
cancel-sign-sub82.5%
cancel-sign-sub-inv82.5%
*-commutative82.5%
*-commutative82.5%
remove-double-neg82.5%
*-commutative82.5%
*-commutative82.5%
Simplified82.5%
add-cube-cbrt82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
Applied egg-rr82.4%
Taylor expanded in t around inf 48.5%
*-commutative48.5%
mul-1-neg48.5%
unsub-neg48.5%
Simplified48.5%
Taylor expanded in c around inf 34.9%
if 5.1999999999999996e-139 < z < 1.25000000000000004e82Initial program 68.6%
cancel-sign-sub68.6%
cancel-sign-sub-inv68.6%
*-commutative68.6%
*-commutative68.6%
remove-double-neg68.6%
*-commutative68.6%
*-commutative68.6%
Simplified68.6%
Taylor expanded in a around inf 50.6%
associate-*r*50.6%
neg-mul-150.6%
cancel-sign-sub50.6%
+-commutative50.6%
mul-1-neg50.6%
unsub-neg50.6%
*-commutative50.6%
Simplified50.6%
Taylor expanded in b around inf 35.1%
if 1.25000000000000004e82 < z Initial program 71.1%
sub-neg71.1%
associate-+l+71.1%
fma-def73.0%
+-commutative73.0%
fma-def73.0%
*-commutative73.0%
*-commutative73.0%
distribute-rgt-neg-in73.0%
sub-neg73.0%
+-commutative73.0%
distribute-neg-in73.0%
unsub-neg73.0%
remove-double-neg73.0%
*-commutative73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in y around inf 58.4%
Taylor expanded in z around inf 54.7%
Final simplification39.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -2.7e+38)
(* c (* b (- z)))
(if (<= z 6.8e-140)
(* c (* t j))
(if (<= z 5.2e+78) (* i (* a b)) (* y (* x z))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.7e+38) {
tmp = c * (b * -z);
} else if (z <= 6.8e-140) {
tmp = c * (t * j);
} else if (z <= 5.2e+78) {
tmp = i * (a * b);
} else {
tmp = y * (x * z);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-2.7d+38)) then
tmp = c * (b * -z)
else if (z <= 6.8d-140) then
tmp = c * (t * j)
else if (z <= 5.2d+78) then
tmp = i * (a * b)
else
tmp = y * (x * z)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.7e+38) {
tmp = c * (b * -z);
} else if (z <= 6.8e-140) {
tmp = c * (t * j);
} else if (z <= 5.2e+78) {
tmp = i * (a * b);
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.7e+38: tmp = c * (b * -z) elif z <= 6.8e-140: tmp = c * (t * j) elif z <= 5.2e+78: tmp = i * (a * b) else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.7e+38) tmp = Float64(c * Float64(b * Float64(-z))); elseif (z <= 6.8e-140) tmp = Float64(c * Float64(t * j)); elseif (z <= 5.2e+78) tmp = Float64(i * Float64(a * b)); else tmp = Float64(y * Float64(x * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.7e+38) tmp = c * (b * -z); elseif (z <= 6.8e-140) tmp = c * (t * j); elseif (z <= 5.2e+78) tmp = i * (a * b); else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.7e+38], N[(c * N[(b * (-z)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.8e-140], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e+78], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.7 \cdot 10^{+38}:\\
\;\;\;\;c \cdot \left(b \cdot \left(-z\right)\right)\\
\mathbf{elif}\;z \leq 6.8 \cdot 10^{-140}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{+78}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if z < -2.69999999999999996e38Initial program 73.4%
cancel-sign-sub73.4%
cancel-sign-sub-inv73.4%
*-commutative73.4%
*-commutative73.4%
remove-double-neg73.4%
*-commutative73.4%
*-commutative73.4%
Simplified73.4%
add-cube-cbrt73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
Applied egg-rr73.3%
Taylor expanded in z around inf 67.4%
Taylor expanded in b around inf 49.3%
mul-1-neg49.3%
*-commutative49.3%
Simplified49.3%
if -2.69999999999999996e38 < z < 6.80000000000000017e-140Initial program 82.5%
cancel-sign-sub82.5%
cancel-sign-sub-inv82.5%
*-commutative82.5%
*-commutative82.5%
remove-double-neg82.5%
*-commutative82.5%
*-commutative82.5%
Simplified82.5%
add-cube-cbrt82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
*-commutative82.4%
Applied egg-rr82.4%
Taylor expanded in t around inf 48.5%
*-commutative48.5%
mul-1-neg48.5%
unsub-neg48.5%
Simplified48.5%
Taylor expanded in c around inf 34.9%
if 6.80000000000000017e-140 < z < 5.2e78Initial program 68.6%
cancel-sign-sub68.6%
cancel-sign-sub-inv68.6%
*-commutative68.6%
*-commutative68.6%
remove-double-neg68.6%
*-commutative68.6%
*-commutative68.6%
Simplified68.6%
Taylor expanded in a around inf 50.6%
associate-*r*50.6%
neg-mul-150.6%
cancel-sign-sub50.6%
+-commutative50.6%
mul-1-neg50.6%
unsub-neg50.6%
*-commutative50.6%
Simplified50.6%
Taylor expanded in b around inf 35.1%
if 5.2e78 < z Initial program 71.1%
sub-neg71.1%
associate-+l+71.1%
fma-def73.0%
+-commutative73.0%
fma-def73.0%
*-commutative73.0%
*-commutative73.0%
distribute-rgt-neg-in73.0%
sub-neg73.0%
+-commutative73.0%
distribute-neg-in73.0%
unsub-neg73.0%
remove-double-neg73.0%
*-commutative73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in y around inf 58.4%
Taylor expanded in z around inf 54.7%
Final simplification41.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= b -7.2e+104) (not (<= b 3.4e+81))) (* i (* a b)) (* c (* t j))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -7.2e+104) || !(b <= 3.4e+81)) {
tmp = i * (a * b);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((b <= (-7.2d+104)) .or. (.not. (b <= 3.4d+81))) then
tmp = i * (a * b)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -7.2e+104) || !(b <= 3.4e+81)) {
tmp = i * (a * b);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (b <= -7.2e+104) or not (b <= 3.4e+81): tmp = i * (a * b) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((b <= -7.2e+104) || !(b <= 3.4e+81)) tmp = Float64(i * Float64(a * b)); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((b <= -7.2e+104) || ~((b <= 3.4e+81))) tmp = i * (a * b); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -7.2e+104], N[Not[LessEqual[b, 3.4e+81]], $MachinePrecision]], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7.2 \cdot 10^{+104} \lor \neg \left(b \leq 3.4 \cdot 10^{+81}\right):\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if b < -7.20000000000000001e104 or 3.40000000000000003e81 < b Initial program 76.9%
cancel-sign-sub76.9%
cancel-sign-sub-inv76.9%
*-commutative76.9%
*-commutative76.9%
remove-double-neg76.9%
*-commutative76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in a around inf 45.9%
associate-*r*45.9%
neg-mul-145.9%
cancel-sign-sub45.9%
+-commutative45.9%
mul-1-neg45.9%
unsub-neg45.9%
*-commutative45.9%
Simplified45.9%
Taylor expanded in b around inf 40.4%
if -7.20000000000000001e104 < b < 3.40000000000000003e81Initial program 75.5%
cancel-sign-sub75.5%
cancel-sign-sub-inv75.5%
*-commutative75.5%
*-commutative75.5%
remove-double-neg75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
add-cube-cbrt75.3%
*-commutative75.3%
*-commutative75.3%
*-commutative75.3%
*-commutative75.3%
*-commutative75.3%
*-commutative75.3%
Applied egg-rr75.3%
Taylor expanded in t around inf 47.1%
*-commutative47.1%
mul-1-neg47.1%
unsub-neg47.1%
Simplified47.1%
Taylor expanded in c around inf 30.6%
Final simplification34.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -4e+145) (* b (* a i)) (if (<= b 4.5e+81) (* c (* t j)) (* a (* b i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -4e+145) {
tmp = b * (a * i);
} else if (b <= 4.5e+81) {
tmp = c * (t * j);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-4d+145)) then
tmp = b * (a * i)
else if (b <= 4.5d+81) then
tmp = c * (t * j)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -4e+145) {
tmp = b * (a * i);
} else if (b <= 4.5e+81) {
tmp = c * (t * j);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -4e+145: tmp = b * (a * i) elif b <= 4.5e+81: tmp = c * (t * j) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -4e+145) tmp = Float64(b * Float64(a * i)); elseif (b <= 4.5e+81) tmp = Float64(c * Float64(t * j)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -4e+145) tmp = b * (a * i); elseif (b <= 4.5e+81) tmp = c * (t * j); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -4e+145], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.5e+81], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -4 \cdot 10^{+145}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;b \leq 4.5 \cdot 10^{+81}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if b < -4e145Initial program 84.7%
cancel-sign-sub84.7%
cancel-sign-sub-inv84.7%
*-commutative84.7%
*-commutative84.7%
remove-double-neg84.7%
*-commutative84.7%
*-commutative84.7%
Simplified84.7%
Taylor expanded in a around inf 38.7%
associate-*r*38.7%
neg-mul-138.7%
cancel-sign-sub38.7%
+-commutative38.7%
mul-1-neg38.7%
unsub-neg38.7%
*-commutative38.7%
Simplified38.7%
Taylor expanded in b around inf 35.7%
associate-*r*32.8%
*-commutative32.8%
associate-*r*27.3%
Simplified27.3%
Taylor expanded in a around 0 35.7%
associate-*r*32.8%
*-commutative32.8%
Simplified32.8%
if -4e145 < b < 4.50000000000000017e81Initial program 75.6%
cancel-sign-sub75.6%
cancel-sign-sub-inv75.6%
*-commutative75.6%
*-commutative75.6%
remove-double-neg75.6%
*-commutative75.6%
*-commutative75.6%
Simplified75.6%
add-cube-cbrt75.4%
*-commutative75.4%
*-commutative75.4%
*-commutative75.4%
*-commutative75.4%
*-commutative75.4%
*-commutative75.4%
Applied egg-rr75.4%
Taylor expanded in t around inf 45.9%
*-commutative45.9%
mul-1-neg45.9%
unsub-neg45.9%
Simplified45.9%
Taylor expanded in c around inf 30.2%
if 4.50000000000000017e81 < b Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in a around inf 54.5%
associate-*r*54.5%
neg-mul-154.5%
cancel-sign-sub54.5%
+-commutative54.5%
mul-1-neg54.5%
unsub-neg54.5%
*-commutative54.5%
Simplified54.5%
Taylor expanded in b around inf 46.4%
associate-*r*40.8%
*-commutative40.8%
associate-*r*42.7%
Simplified42.7%
Final simplification32.9%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* b i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = a * (b * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
def code(x, y, z, t, a, b, c, i, j): return a * (b * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(b * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (b * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(b \cdot i\right)
\end{array}
Initial program 76.0%
cancel-sign-sub76.0%
cancel-sign-sub-inv76.0%
*-commutative76.0%
*-commutative76.0%
remove-double-neg76.0%
*-commutative76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in a around inf 32.6%
associate-*r*32.6%
neg-mul-132.6%
cancel-sign-sub32.6%
+-commutative32.6%
mul-1-neg32.6%
unsub-neg32.6%
*-commutative32.6%
Simplified32.6%
Taylor expanded in b around inf 19.8%
associate-*r*18.8%
*-commutative18.8%
associate-*r*17.4%
Simplified17.4%
Final simplification17.4%
(FPCore (x y z t a b c i j) :precision binary64 (* b (* a i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = b * (a * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
def code(x, y, z, t, a, b, c, i, j): return b * (a * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(b * Float64(a * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = b * (a * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
b \cdot \left(a \cdot i\right)
\end{array}
Initial program 76.0%
cancel-sign-sub76.0%
cancel-sign-sub-inv76.0%
*-commutative76.0%
*-commutative76.0%
remove-double-neg76.0%
*-commutative76.0%
*-commutative76.0%
Simplified76.0%
Taylor expanded in a around inf 32.6%
associate-*r*32.6%
neg-mul-132.6%
cancel-sign-sub32.6%
+-commutative32.6%
mul-1-neg32.6%
unsub-neg32.6%
*-commutative32.6%
Simplified32.6%
Taylor expanded in b around inf 19.8%
associate-*r*18.8%
*-commutative18.8%
associate-*r*17.4%
Simplified17.4%
Taylor expanded in a around 0 19.8%
associate-*r*18.8%
*-commutative18.8%
Simplified18.8%
Final simplification18.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2023195
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:herbie-target
(if (< t -8.120978919195912e-33) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -4.712553818218485e-169) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (if (< t -7.633533346031584e-308) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 1.0535888557455487e-139) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))