
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); 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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))
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) - (t * i)))) + (j * ((c * a) - (y * 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 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * 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 ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i)))
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(t * i)))) + Float64(j * Float64(Float64(c * a) - Float64(y * i)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (t * i)))) + (j * ((c * a) - (y * i))); 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[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - t \cdot i\right)\right) + j \cdot \left(c \cdot a - y \cdot i\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* x y) (* b c)))
(t_2
(+
(* j (- (* a c) (* y i)))
(+ (* x (- (* y z) (* t a))) (* b (- (* t i) (* z c)))))))
(if (<= t_2 INFINITY) t_2 (* z (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 = (x * y) - (b * c);
double t_2 = (j * ((a * c) - (y * i))) + ((x * ((y * z) - (t * a))) + (b * ((t * i) - (z * c))));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = z * 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 = (x * y) - (b * c);
double t_2 = (j * ((a * c) - (y * i))) + ((x * ((y * z) - (t * a))) + (b * ((t * i) - (z * c))));
double tmp;
if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = z * 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(x * y) - Float64(b * c)) t_2 = Float64(Float64(j * Float64(Float64(a * c) - Float64(y * i))) + Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(t * i) - Float64(z * c))))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; else tmp = Float64(z * 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[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(j * N[(N[(a * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, N[(z * 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 := x \cdot y - b \cdot c\\
t_2 := j \cdot \left(a \cdot c - y \cdot i\right) + \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(t \cdot i - z \cdot c\right)\right)\\
\mathbf{if}\;t_2 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;z \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 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +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 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
Simplified0.0%
Taylor expanded in z around inf 45.8%
add-cbrt-cube64.1%
*-commutative64.1%
*-commutative64.1%
*-commutative64.1%
Applied egg-rr64.1%
associate-*l*64.1%
*-commutative64.1%
*-commutative64.1%
*-commutative64.1%
Simplified64.1%
Final simplification87.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(* j (- (* a c) (* y i)))
(+ (* x (- (* y z) (* t a))) (* b (- (* t i) (* z c)))))))
(if (<= t_1 INFINITY)
t_1
(* z (cbrt (* (- (* x y) (* b c)) (* c (* b (* b c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((a * c) - (y * i))) + ((x * ((y * z) - (t * a))) + (b * ((t * i) - (z * c))));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = z * cbrt((((x * y) - (b * c)) * (c * (b * (b * c)))));
}
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 = (j * ((a * c) - (y * i))) + ((x * ((y * z) - (t * a))) + (b * ((t * i) - (z * c))));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = z * Math.cbrt((((x * y) - (b * c)) * (c * (b * (b * c)))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(j * Float64(Float64(a * c) - Float64(y * i))) + Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(t * i) - Float64(z * c))))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(z * cbrt(Float64(Float64(Float64(x * y) - Float64(b * c)) * Float64(c * Float64(b * Float64(b * c)))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(j * N[(N[(a * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(z * N[Power[N[(N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision] * N[(c * N[(b * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(a \cdot c - y \cdot i\right) + \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(t \cdot i - z \cdot c\right)\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \sqrt[3]{\left(x \cdot y - b \cdot c\right) \cdot \left(c \cdot \left(b \cdot \left(b \cdot c\right)\right)\right)}\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +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 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
Simplified0.0%
Taylor expanded in z around inf 45.8%
add-cbrt-cube64.1%
*-commutative64.1%
*-commutative64.1%
*-commutative64.1%
Applied egg-rr64.1%
associate-*l*64.1%
*-commutative64.1%
*-commutative64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in y around 0 49.2%
unpow249.2%
unpow249.2%
swap-sqr55.8%
associate-*l*53.6%
Simplified53.6%
Final simplification85.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a))))
(t_2 (+ (* j (- (* a c) (* y i))) (+ t_1 (* b (- (* t i) (* z c)))))))
(if (<= t_2 INFINITY) t_2 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 t_2 = (j * ((a * c) - (y * i))) + (t_1 + (b * ((t * i) - (z * c))));
double tmp;
if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = 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 = x * ((y * z) - (t * a));
double t_2 = (j * ((a * c) - (y * i))) + (t_1 + (b * ((t * i) - (z * c))));
double tmp;
if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) t_2 = (j * ((a * c) - (y * i))) + (t_1 + (b * ((t * i) - (z * c)))) tmp = 0 if t_2 <= math.inf: tmp = t_2 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))) t_2 = Float64(Float64(j * Float64(Float64(a * c) - Float64(y * i))) + Float64(t_1 + Float64(b * Float64(Float64(t * i) - Float64(z * c))))) tmp = 0.0 if (t_2 <= Inf) tmp = t_2; 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)); t_2 = (j * ((a * c) - (y * i))) + (t_1 + (b * ((t * i) - (z * c)))); tmp = 0.0; if (t_2 <= Inf) tmp = t_2; 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]}, Block[{t$95$2 = N[(N[(j * N[(N[(a * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 + N[(b * N[(N[(t * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, Infinity], t$95$2, t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := j \cdot \left(a \cdot c - y \cdot i\right) + \left(t_1 + b \cdot \left(t \cdot i - z \cdot c\right)\right)\\
\mathbf{if}\;t_2 \leq \infty:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) < +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 t i)))) (*.f64 j (-.f64 (*.f64 c a) (*.f64 y i)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
Simplified0.0%
Taylor expanded in x around inf 51.9%
Final simplification85.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* i (- j)))) (t_2 (* a (- (* c j) (* x t)))))
(if (<= z -5e+51)
(* z (* b (- c)))
(if (<= z -1.6e-36)
t_2
(if (<= z -1.55e-159)
t_1
(if (<= z -4.5e-305)
t_2
(if (<= z 1.45e-288)
t_1
(if (<= z 3e-107)
t_2
(if (<= z 2.4e+41)
(* t (* b i))
(if (<= z 7.4e+96) t_2 (* y (* x z))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = y * (i * -j);
double t_2 = a * ((c * j) - (x * t));
double tmp;
if (z <= -5e+51) {
tmp = z * (b * -c);
} else if (z <= -1.6e-36) {
tmp = t_2;
} else if (z <= -1.55e-159) {
tmp = t_1;
} else if (z <= -4.5e-305) {
tmp = t_2;
} else if (z <= 1.45e-288) {
tmp = t_1;
} else if (z <= 3e-107) {
tmp = t_2;
} else if (z <= 2.4e+41) {
tmp = t * (b * i);
} else if (z <= 7.4e+96) {
tmp = t_2;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = y * (i * -j)
t_2 = a * ((c * j) - (x * t))
if (z <= (-5d+51)) then
tmp = z * (b * -c)
else if (z <= (-1.6d-36)) then
tmp = t_2
else if (z <= (-1.55d-159)) then
tmp = t_1
else if (z <= (-4.5d-305)) then
tmp = t_2
else if (z <= 1.45d-288) then
tmp = t_1
else if (z <= 3d-107) then
tmp = t_2
else if (z <= 2.4d+41) then
tmp = t * (b * i)
else if (z <= 7.4d+96) then
tmp = t_2
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 t_1 = y * (i * -j);
double t_2 = a * ((c * j) - (x * t));
double tmp;
if (z <= -5e+51) {
tmp = z * (b * -c);
} else if (z <= -1.6e-36) {
tmp = t_2;
} else if (z <= -1.55e-159) {
tmp = t_1;
} else if (z <= -4.5e-305) {
tmp = t_2;
} else if (z <= 1.45e-288) {
tmp = t_1;
} else if (z <= 3e-107) {
tmp = t_2;
} else if (z <= 2.4e+41) {
tmp = t * (b * i);
} else if (z <= 7.4e+96) {
tmp = t_2;
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (i * -j) t_2 = a * ((c * j) - (x * t)) tmp = 0 if z <= -5e+51: tmp = z * (b * -c) elif z <= -1.6e-36: tmp = t_2 elif z <= -1.55e-159: tmp = t_1 elif z <= -4.5e-305: tmp = t_2 elif z <= 1.45e-288: tmp = t_1 elif z <= 3e-107: tmp = t_2 elif z <= 2.4e+41: tmp = t * (b * i) elif z <= 7.4e+96: tmp = t_2 else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(i * Float64(-j))) t_2 = Float64(a * Float64(Float64(c * j) - Float64(x * t))) tmp = 0.0 if (z <= -5e+51) tmp = Float64(z * Float64(b * Float64(-c))); elseif (z <= -1.6e-36) tmp = t_2; elseif (z <= -1.55e-159) tmp = t_1; elseif (z <= -4.5e-305) tmp = t_2; elseif (z <= 1.45e-288) tmp = t_1; elseif (z <= 3e-107) tmp = t_2; elseif (z <= 2.4e+41) tmp = Float64(t * Float64(b * i)); elseif (z <= 7.4e+96) tmp = t_2; else tmp = Float64(y * Float64(x * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * (i * -j); t_2 = a * ((c * j) - (x * t)); tmp = 0.0; if (z <= -5e+51) tmp = z * (b * -c); elseif (z <= -1.6e-36) tmp = t_2; elseif (z <= -1.55e-159) tmp = t_1; elseif (z <= -4.5e-305) tmp = t_2; elseif (z <= 1.45e-288) tmp = t_1; elseif (z <= 3e-107) tmp = t_2; elseif (z <= 2.4e+41) tmp = t * (b * i); elseif (z <= 7.4e+96) tmp = t_2; else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e+51], N[(z * N[(b * (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.6e-36], t$95$2, If[LessEqual[z, -1.55e-159], t$95$1, If[LessEqual[z, -4.5e-305], t$95$2, If[LessEqual[z, 1.45e-288], t$95$1, If[LessEqual[z, 3e-107], t$95$2, If[LessEqual[z, 2.4e+41], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.4e+96], t$95$2, N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(i \cdot \left(-j\right)\right)\\
t_2 := a \cdot \left(c \cdot j - x \cdot t\right)\\
\mathbf{if}\;z \leq -5 \cdot 10^{+51}:\\
\;\;\;\;z \cdot \left(b \cdot \left(-c\right)\right)\\
\mathbf{elif}\;z \leq -1.6 \cdot 10^{-36}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -1.55 \cdot 10^{-159}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -4.5 \cdot 10^{-305}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{-288}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 3 \cdot 10^{-107}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+41}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;z \leq 7.4 \cdot 10^{+96}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if z < -5e51Initial program 67.6%
cancel-sign-sub67.6%
cancel-sign-sub-inv67.6%
*-commutative67.6%
remove-double-neg67.6%
*-commutative67.6%
Simplified67.6%
Taylor expanded in z around inf 77.4%
Taylor expanded in y around 0 53.9%
neg-mul-153.9%
distribute-rgt-neg-in53.9%
Simplified53.9%
if -5e51 < z < -1.60000000000000011e-36 or -1.55e-159 < z < -4.5000000000000002e-305 or 1.45000000000000007e-288 < z < 2.9999999999999997e-107 or 2.4000000000000002e41 < z < 7.39999999999999982e96Initial program 77.2%
cancel-sign-sub77.2%
cancel-sign-sub-inv77.2%
*-commutative77.2%
remove-double-neg77.2%
*-commutative77.2%
Simplified77.2%
Taylor expanded in y around 0 76.3%
Taylor expanded in a around inf 53.7%
+-commutative53.7%
mul-1-neg53.7%
unsub-neg53.7%
*-commutative53.7%
Simplified53.7%
if -1.60000000000000011e-36 < z < -1.55e-159 or -4.5000000000000002e-305 < z < 1.45000000000000007e-288Initial program 79.4%
cancel-sign-sub79.4%
cancel-sign-sub-inv79.4%
*-commutative79.4%
remove-double-neg79.4%
*-commutative79.4%
Simplified79.4%
Taylor expanded in y around inf 57.0%
*-commutative57.0%
mul-1-neg57.0%
unsub-neg57.0%
Simplified57.0%
Taylor expanded in z around 0 47.8%
mul-1-neg47.8%
distribute-rgt-neg-in47.8%
*-commutative47.8%
Simplified47.8%
if 2.9999999999999997e-107 < z < 2.4000000000000002e41Initial program 76.9%
cancel-sign-sub76.9%
cancel-sign-sub-inv76.9%
*-commutative76.9%
remove-double-neg76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in t around inf 54.9%
*-commutative54.9%
associate-*r*54.9%
neg-mul-154.9%
cancel-sign-sub54.9%
+-commutative54.9%
mul-1-neg54.9%
unsub-neg54.9%
Simplified54.9%
Taylor expanded in i around inf 51.3%
if 7.39999999999999982e96 < z Initial program 76.4%
cancel-sign-sub76.4%
cancel-sign-sub-inv76.4%
*-commutative76.4%
remove-double-neg76.4%
*-commutative76.4%
Simplified76.4%
Taylor expanded in y around inf 57.5%
*-commutative57.5%
mul-1-neg57.5%
unsub-neg57.5%
Simplified57.5%
Taylor expanded in z around inf 53.9%
Final simplification52.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* t i) (* z c)))) (t_2 (* y (- (* x z) (* i j)))))
(if (<= y -1.16e+126)
t_2
(if (<= y -2.9e+17)
t_1
(if (<= y -0.0215)
(* j (- (* a c) (* y i)))
(if (<= y -4e-62)
t_1
(if (<= y -2.15e-116)
(* a (- (* c j) (* x t)))
(if (<= y 5.5e-195)
t_1
(if (<= y 1.4e-44)
(* t (- (* b i) (* x a)))
(if (<= y 400000000000.0) 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 = b * ((t * i) - (z * c));
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.16e+126) {
tmp = t_2;
} else if (y <= -2.9e+17) {
tmp = t_1;
} else if (y <= -0.0215) {
tmp = j * ((a * c) - (y * i));
} else if (y <= -4e-62) {
tmp = t_1;
} else if (y <= -2.15e-116) {
tmp = a * ((c * j) - (x * t));
} else if (y <= 5.5e-195) {
tmp = t_1;
} else if (y <= 1.4e-44) {
tmp = t * ((b * i) - (x * a));
} else if (y <= 400000000000.0) {
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 = b * ((t * i) - (z * c))
t_2 = y * ((x * z) - (i * j))
if (y <= (-1.16d+126)) then
tmp = t_2
else if (y <= (-2.9d+17)) then
tmp = t_1
else if (y <= (-0.0215d0)) then
tmp = j * ((a * c) - (y * i))
else if (y <= (-4d-62)) then
tmp = t_1
else if (y <= (-2.15d-116)) then
tmp = a * ((c * j) - (x * t))
else if (y <= 5.5d-195) then
tmp = t_1
else if (y <= 1.4d-44) then
tmp = t * ((b * i) - (x * a))
else if (y <= 400000000000.0d0) 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 = b * ((t * i) - (z * c));
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.16e+126) {
tmp = t_2;
} else if (y <= -2.9e+17) {
tmp = t_1;
} else if (y <= -0.0215) {
tmp = j * ((a * c) - (y * i));
} else if (y <= -4e-62) {
tmp = t_1;
} else if (y <= -2.15e-116) {
tmp = a * ((c * j) - (x * t));
} else if (y <= 5.5e-195) {
tmp = t_1;
} else if (y <= 1.4e-44) {
tmp = t * ((b * i) - (x * a));
} else if (y <= 400000000000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((t * i) - (z * c)) t_2 = y * ((x * z) - (i * j)) tmp = 0 if y <= -1.16e+126: tmp = t_2 elif y <= -2.9e+17: tmp = t_1 elif y <= -0.0215: tmp = j * ((a * c) - (y * i)) elif y <= -4e-62: tmp = t_1 elif y <= -2.15e-116: tmp = a * ((c * j) - (x * t)) elif y <= 5.5e-195: tmp = t_1 elif y <= 1.4e-44: tmp = t * ((b * i) - (x * a)) elif y <= 400000000000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(t * i) - Float64(z * c))) t_2 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -1.16e+126) tmp = t_2; elseif (y <= -2.9e+17) tmp = t_1; elseif (y <= -0.0215) tmp = Float64(j * Float64(Float64(a * c) - Float64(y * i))); elseif (y <= -4e-62) tmp = t_1; elseif (y <= -2.15e-116) tmp = Float64(a * Float64(Float64(c * j) - Float64(x * t))); elseif (y <= 5.5e-195) tmp = t_1; elseif (y <= 1.4e-44) tmp = Float64(t * Float64(Float64(b * i) - Float64(x * a))); elseif (y <= 400000000000.0) 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 = b * ((t * i) - (z * c)); t_2 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -1.16e+126) tmp = t_2; elseif (y <= -2.9e+17) tmp = t_1; elseif (y <= -0.0215) tmp = j * ((a * c) - (y * i)); elseif (y <= -4e-62) tmp = t_1; elseif (y <= -2.15e-116) tmp = a * ((c * j) - (x * t)); elseif (y <= 5.5e-195) tmp = t_1; elseif (y <= 1.4e-44) tmp = t * ((b * i) - (x * a)); elseif (y <= 400000000000.0) 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[(b * N[(N[(t * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.16e+126], t$95$2, If[LessEqual[y, -2.9e+17], t$95$1, If[LessEqual[y, -0.0215], N[(j * N[(N[(a * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -4e-62], t$95$1, If[LessEqual[y, -2.15e-116], N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.5e-195], t$95$1, If[LessEqual[y, 1.4e-44], N[(t * N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 400000000000.0], t$95$1, t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(t \cdot i - z \cdot c\right)\\
t_2 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -1.16 \cdot 10^{+126}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq -2.9 \cdot 10^{+17}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -0.0215:\\
\;\;\;\;j \cdot \left(a \cdot c - y \cdot i\right)\\
\mathbf{elif}\;y \leq -4 \cdot 10^{-62}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -2.15 \cdot 10^{-116}:\\
\;\;\;\;a \cdot \left(c \cdot j - x \cdot t\right)\\
\mathbf{elif}\;y \leq 5.5 \cdot 10^{-195}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{-44}:\\
\;\;\;\;t \cdot \left(b \cdot i - x \cdot a\right)\\
\mathbf{elif}\;y \leq 400000000000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -1.15999999999999997e126 or 4e11 < y Initial program 67.0%
cancel-sign-sub67.0%
cancel-sign-sub-inv67.0%
*-commutative67.0%
remove-double-neg67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in y around inf 73.7%
*-commutative73.7%
mul-1-neg73.7%
unsub-neg73.7%
Simplified73.7%
if -1.15999999999999997e126 < y < -2.9e17 or -0.021499999999999998 < y < -4.0000000000000002e-62 or -2.1499999999999999e-116 < y < 5.5000000000000003e-195 or 1.4e-44 < y < 4e11Initial program 82.7%
cancel-sign-sub82.7%
cancel-sign-sub-inv82.7%
*-commutative82.7%
remove-double-neg82.7%
*-commutative82.7%
Simplified82.7%
Taylor expanded in b around inf 63.8%
if -2.9e17 < y < -0.021499999999999998Initial program 85.0%
cancel-sign-sub85.0%
cancel-sign-sub-inv85.0%
*-commutative85.0%
remove-double-neg85.0%
*-commutative85.0%
Simplified85.0%
Taylor expanded in j around inf 85.6%
if -4.0000000000000002e-62 < y < -2.1499999999999999e-116Initial program 75.3%
cancel-sign-sub75.3%
cancel-sign-sub-inv75.3%
*-commutative75.3%
remove-double-neg75.3%
*-commutative75.3%
Simplified75.3%
Taylor expanded in y around 0 75.4%
Taylor expanded in a around inf 83.9%
+-commutative83.9%
mul-1-neg83.9%
unsub-neg83.9%
*-commutative83.9%
Simplified83.9%
if 5.5000000000000003e-195 < y < 1.4e-44Initial program 73.4%
cancel-sign-sub73.4%
cancel-sign-sub-inv73.4%
*-commutative73.4%
remove-double-neg73.4%
*-commutative73.4%
Simplified73.4%
Taylor expanded in t around inf 55.1%
*-commutative55.1%
associate-*r*55.1%
neg-mul-155.1%
cancel-sign-sub55.1%
+-commutative55.1%
mul-1-neg55.1%
unsub-neg55.1%
Simplified55.1%
Final simplification68.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* x (- (* y z) (* t a))) (* b (- (* t i) (* z c))))))
(if (<= t -2.2e-93)
t_1
(if (<= t 1.75e-44)
(+ (* y (- (* x z) (* i j))) (* c (- (* a j) (* z b))))
(if (<= t 1.75e+163) t_1 (* t (- (* b i) (* 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 * ((t * i) - (z * c)));
double tmp;
if (t <= -2.2e-93) {
tmp = t_1;
} else if (t <= 1.75e-44) {
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)));
} else if (t <= 1.75e+163) {
tmp = t_1;
} else {
tmp = t * ((b * i) - (x * a));
}
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))) + (b * ((t * i) - (z * c)))
if (t <= (-2.2d-93)) then
tmp = t_1
else if (t <= 1.75d-44) then
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)))
else if (t <= 1.75d+163) then
tmp = t_1
else
tmp = t * ((b * i) - (x * a))
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 * ((t * i) - (z * c)));
double tmp;
if (t <= -2.2e-93) {
tmp = t_1;
} else if (t <= 1.75e-44) {
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)));
} else if (t <= 1.75e+163) {
tmp = t_1;
} else {
tmp = t * ((b * i) - (x * a));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (x * ((y * z) - (t * a))) + (b * ((t * i) - (z * c))) tmp = 0 if t <= -2.2e-93: tmp = t_1 elif t <= 1.75e-44: tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b))) elif t <= 1.75e+163: tmp = t_1 else: tmp = t * ((b * i) - (x * a)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(t * i) - Float64(z * c)))) tmp = 0.0 if (t <= -2.2e-93) tmp = t_1; elseif (t <= 1.75e-44) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(c * Float64(Float64(a * j) - Float64(z * b)))); elseif (t <= 1.75e+163) tmp = t_1; else tmp = Float64(t * Float64(Float64(b * i) - 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 * ((t * i) - (z * c))); tmp = 0.0; if (t <= -2.2e-93) tmp = t_1; elseif (t <= 1.75e-44) tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b))); elseif (t <= 1.75e+163) tmp = t_1; else tmp = t * ((b * i) - (x * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(t * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.2e-93], t$95$1, If[LessEqual[t, 1.75e-44], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.75e+163], t$95$1, N[(t * N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(t \cdot i - z \cdot c\right)\\
\mathbf{if}\;t \leq -2.2 \cdot 10^{-93}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{-44}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + c \cdot \left(a \cdot j - z \cdot b\right)\\
\mathbf{elif}\;t \leq 1.75 \cdot 10^{+163}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(b \cdot i - x \cdot a\right)\\
\end{array}
\end{array}
if t < -2.19999999999999996e-93 or 1.7499999999999999e-44 < t < 1.7500000000000001e163Initial program 74.4%
cancel-sign-sub74.4%
cancel-sign-sub-inv74.4%
*-commutative74.4%
remove-double-neg74.4%
*-commutative74.4%
Simplified74.4%
Taylor expanded in j around 0 71.5%
if -2.19999999999999996e-93 < t < 1.7499999999999999e-44Initial program 87.1%
cancel-sign-sub87.1%
cancel-sign-sub-inv87.1%
*-commutative87.1%
remove-double-neg87.1%
*-commutative87.1%
Simplified87.1%
Taylor expanded in y around 0 85.3%
Taylor expanded in t around 0 71.0%
sub-neg71.0%
+-commutative71.0%
+-commutative71.0%
associate-+r+71.0%
*-commutative71.0%
*-commutative71.0%
mul-1-neg71.0%
*-commutative71.0%
associate-*r*72.9%
distribute-rgt-neg-in72.9%
*-commutative72.9%
distribute-lft-in74.8%
+-commutative74.8%
sub-neg74.8%
Simplified75.8%
if 1.7500000000000001e163 < t Initial program 44.9%
cancel-sign-sub44.9%
cancel-sign-sub-inv44.9%
*-commutative44.9%
remove-double-neg44.9%
*-commutative44.9%
Simplified44.9%
Taylor expanded in t around inf 76.7%
*-commutative76.7%
associate-*r*76.7%
neg-mul-176.7%
cancel-sign-sub76.7%
+-commutative76.7%
mul-1-neg76.7%
unsub-neg76.7%
Simplified76.7%
Final simplification73.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* a j) (* z b))))
(t_2 (* t (- (* b i) (* x a))))
(t_3 (* y (- (* x z) (* i j)))))
(if (<= y -4.2e+75)
t_3
(if (<= y -1.15e+35)
t_1
(if (<= y -2.05e-32)
(* i (- (* t b) (* y j)))
(if (<= y -1.5e-98)
t_2
(if (<= y 6.6e-195)
t_1
(if (<= y 1.15e-44)
t_2
(if (<= y 3900000000000.0) t_1 t_3)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((a * j) - (z * b));
double t_2 = t * ((b * i) - (x * a));
double t_3 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.2e+75) {
tmp = t_3;
} else if (y <= -1.15e+35) {
tmp = t_1;
} else if (y <= -2.05e-32) {
tmp = i * ((t * b) - (y * j));
} else if (y <= -1.5e-98) {
tmp = t_2;
} else if (y <= 6.6e-195) {
tmp = t_1;
} else if (y <= 1.15e-44) {
tmp = t_2;
} else if (y <= 3900000000000.0) {
tmp = t_1;
} else {
tmp = t_3;
}
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) :: t_3
real(8) :: tmp
t_1 = c * ((a * j) - (z * b))
t_2 = t * ((b * i) - (x * a))
t_3 = y * ((x * z) - (i * j))
if (y <= (-4.2d+75)) then
tmp = t_3
else if (y <= (-1.15d+35)) then
tmp = t_1
else if (y <= (-2.05d-32)) then
tmp = i * ((t * b) - (y * j))
else if (y <= (-1.5d-98)) then
tmp = t_2
else if (y <= 6.6d-195) then
tmp = t_1
else if (y <= 1.15d-44) then
tmp = t_2
else if (y <= 3900000000000.0d0) then
tmp = t_1
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((a * j) - (z * b));
double t_2 = t * ((b * i) - (x * a));
double t_3 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.2e+75) {
tmp = t_3;
} else if (y <= -1.15e+35) {
tmp = t_1;
} else if (y <= -2.05e-32) {
tmp = i * ((t * b) - (y * j));
} else if (y <= -1.5e-98) {
tmp = t_2;
} else if (y <= 6.6e-195) {
tmp = t_1;
} else if (y <= 1.15e-44) {
tmp = t_2;
} else if (y <= 3900000000000.0) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((a * j) - (z * b)) t_2 = t * ((b * i) - (x * a)) t_3 = y * ((x * z) - (i * j)) tmp = 0 if y <= -4.2e+75: tmp = t_3 elif y <= -1.15e+35: tmp = t_1 elif y <= -2.05e-32: tmp = i * ((t * b) - (y * j)) elif y <= -1.5e-98: tmp = t_2 elif y <= 6.6e-195: tmp = t_1 elif y <= 1.15e-44: tmp = t_2 elif y <= 3900000000000.0: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(a * j) - Float64(z * b))) t_2 = Float64(t * Float64(Float64(b * i) - Float64(x * a))) t_3 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -4.2e+75) tmp = t_3; elseif (y <= -1.15e+35) tmp = t_1; elseif (y <= -2.05e-32) tmp = Float64(i * Float64(Float64(t * b) - Float64(y * j))); elseif (y <= -1.5e-98) tmp = t_2; elseif (y <= 6.6e-195) tmp = t_1; elseif (y <= 1.15e-44) tmp = t_2; elseif (y <= 3900000000000.0) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((a * j) - (z * b)); t_2 = t * ((b * i) - (x * a)); t_3 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -4.2e+75) tmp = t_3; elseif (y <= -1.15e+35) tmp = t_1; elseif (y <= -2.05e-32) tmp = i * ((t * b) - (y * j)); elseif (y <= -1.5e-98) tmp = t_2; elseif (y <= 6.6e-195) tmp = t_1; elseif (y <= 1.15e-44) tmp = t_2; elseif (y <= 3900000000000.0) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.2e+75], t$95$3, If[LessEqual[y, -1.15e+35], t$95$1, If[LessEqual[y, -2.05e-32], N[(i * N[(N[(t * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.5e-98], t$95$2, If[LessEqual[y, 6.6e-195], t$95$1, If[LessEqual[y, 1.15e-44], t$95$2, If[LessEqual[y, 3900000000000.0], t$95$1, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(a \cdot j - z \cdot b\right)\\
t_2 := t \cdot \left(b \cdot i - x \cdot a\right)\\
t_3 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -4.2 \cdot 10^{+75}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;y \leq -1.15 \cdot 10^{+35}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq -2.05 \cdot 10^{-32}:\\
\;\;\;\;i \cdot \left(t \cdot b - y \cdot j\right)\\
\mathbf{elif}\;y \leq -1.5 \cdot 10^{-98}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 6.6 \cdot 10^{-195}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-44}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 3900000000000:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if y < -4.19999999999999997e75 or 3.9e12 < y Initial program 65.4%
cancel-sign-sub65.4%
cancel-sign-sub-inv65.4%
*-commutative65.4%
remove-double-neg65.4%
*-commutative65.4%
Simplified65.4%
Taylor expanded in y around inf 70.7%
*-commutative70.7%
mul-1-neg70.7%
unsub-neg70.7%
Simplified70.7%
if -4.19999999999999997e75 < y < -1.1499999999999999e35 or -1.5e-98 < y < 6.6e-195 or 1.14999999999999999e-44 < y < 3.9e12Initial program 84.4%
cancel-sign-sub84.4%
cancel-sign-sub-inv84.4%
*-commutative84.4%
remove-double-neg84.4%
*-commutative84.4%
Simplified84.4%
Taylor expanded in c around inf 60.2%
*-commutative60.2%
Simplified60.2%
if -1.1499999999999999e35 < y < -2.04999999999999988e-32Initial program 88.6%
cancel-sign-sub88.6%
cancel-sign-sub-inv88.6%
*-commutative88.6%
remove-double-neg88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in i around inf 61.9%
sub-neg61.9%
mul-1-neg61.9%
remove-double-neg61.9%
+-commutative61.9%
mul-1-neg61.9%
unsub-neg61.9%
*-commutative61.9%
Simplified61.9%
if -2.04999999999999988e-32 < y < -1.5e-98 or 6.6e-195 < y < 1.14999999999999999e-44Initial program 75.8%
cancel-sign-sub75.8%
cancel-sign-sub-inv75.8%
*-commutative75.8%
remove-double-neg75.8%
*-commutative75.8%
Simplified75.8%
Taylor expanded in t around inf 58.9%
*-commutative58.9%
associate-*r*58.9%
neg-mul-158.9%
cancel-sign-sub58.9%
+-commutative58.9%
mul-1-neg58.9%
unsub-neg58.9%
Simplified58.9%
Final simplification64.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* t b) (* y j))))
(t_2 (* a (- (* c j) (* x t))))
(t_3 (* z (- (* x y) (* b c)))))
(if (<= z -2.6e+44)
t_3
(if (<= z -5.1e-36)
t_2
(if (<= z 1.45e-66)
t_1
(if (<= z 170000.0)
(* c (- (* a j) (* z b)))
(if (<= z 2.05e+40)
t_1
(if (<= z 2.65e+75)
t_2
(if (<= z 4e+75) (* t (* b i)) t_3)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((t * b) - (y * j));
double t_2 = a * ((c * j) - (x * t));
double t_3 = z * ((x * y) - (b * c));
double tmp;
if (z <= -2.6e+44) {
tmp = t_3;
} else if (z <= -5.1e-36) {
tmp = t_2;
} else if (z <= 1.45e-66) {
tmp = t_1;
} else if (z <= 170000.0) {
tmp = c * ((a * j) - (z * b));
} else if (z <= 2.05e+40) {
tmp = t_1;
} else if (z <= 2.65e+75) {
tmp = t_2;
} else if (z <= 4e+75) {
tmp = t * (b * i);
} else {
tmp = t_3;
}
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) :: t_3
real(8) :: tmp
t_1 = i * ((t * b) - (y * j))
t_2 = a * ((c * j) - (x * t))
t_3 = z * ((x * y) - (b * c))
if (z <= (-2.6d+44)) then
tmp = t_3
else if (z <= (-5.1d-36)) then
tmp = t_2
else if (z <= 1.45d-66) then
tmp = t_1
else if (z <= 170000.0d0) then
tmp = c * ((a * j) - (z * b))
else if (z <= 2.05d+40) then
tmp = t_1
else if (z <= 2.65d+75) then
tmp = t_2
else if (z <= 4d+75) then
tmp = t * (b * i)
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((t * b) - (y * j));
double t_2 = a * ((c * j) - (x * t));
double t_3 = z * ((x * y) - (b * c));
double tmp;
if (z <= -2.6e+44) {
tmp = t_3;
} else if (z <= -5.1e-36) {
tmp = t_2;
} else if (z <= 1.45e-66) {
tmp = t_1;
} else if (z <= 170000.0) {
tmp = c * ((a * j) - (z * b));
} else if (z <= 2.05e+40) {
tmp = t_1;
} else if (z <= 2.65e+75) {
tmp = t_2;
} else if (z <= 4e+75) {
tmp = t * (b * i);
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((t * b) - (y * j)) t_2 = a * ((c * j) - (x * t)) t_3 = z * ((x * y) - (b * c)) tmp = 0 if z <= -2.6e+44: tmp = t_3 elif z <= -5.1e-36: tmp = t_2 elif z <= 1.45e-66: tmp = t_1 elif z <= 170000.0: tmp = c * ((a * j) - (z * b)) elif z <= 2.05e+40: tmp = t_1 elif z <= 2.65e+75: tmp = t_2 elif z <= 4e+75: tmp = t * (b * i) else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(t * b) - Float64(y * j))) t_2 = Float64(a * Float64(Float64(c * j) - Float64(x * t))) t_3 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -2.6e+44) tmp = t_3; elseif (z <= -5.1e-36) tmp = t_2; elseif (z <= 1.45e-66) tmp = t_1; elseif (z <= 170000.0) tmp = Float64(c * Float64(Float64(a * j) - Float64(z * b))); elseif (z <= 2.05e+40) tmp = t_1; elseif (z <= 2.65e+75) tmp = t_2; elseif (z <= 4e+75) tmp = Float64(t * Float64(b * i)); else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * ((t * b) - (y * j)); t_2 = a * ((c * j) - (x * t)); t_3 = z * ((x * y) - (b * c)); tmp = 0.0; if (z <= -2.6e+44) tmp = t_3; elseif (z <= -5.1e-36) tmp = t_2; elseif (z <= 1.45e-66) tmp = t_1; elseif (z <= 170000.0) tmp = c * ((a * j) - (z * b)); elseif (z <= 2.05e+40) tmp = t_1; elseif (z <= 2.65e+75) tmp = t_2; elseif (z <= 4e+75) tmp = t * (b * i); else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(N[(t * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.6e+44], t$95$3, If[LessEqual[z, -5.1e-36], t$95$2, If[LessEqual[z, 1.45e-66], t$95$1, If[LessEqual[z, 170000.0], N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.05e+40], t$95$1, If[LessEqual[z, 2.65e+75], t$95$2, If[LessEqual[z, 4e+75], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(t \cdot b - y \cdot j\right)\\
t_2 := a \cdot \left(c \cdot j - x \cdot t\right)\\
t_3 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -2.6 \cdot 10^{+44}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;z \leq -5.1 \cdot 10^{-36}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{-66}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 170000:\\
\;\;\;\;c \cdot \left(a \cdot j - z \cdot b\right)\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{+40}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 2.65 \cdot 10^{+75}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+75}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if z < -2.5999999999999999e44 or 3.99999999999999971e75 < z Initial program 73.2%
cancel-sign-sub73.2%
cancel-sign-sub-inv73.2%
*-commutative73.2%
remove-double-neg73.2%
*-commutative73.2%
Simplified73.2%
Taylor expanded in z around inf 76.8%
if -2.5999999999999999e44 < z < -5.09999999999999973e-36 or 2.0500000000000001e40 < z < 2.6499999999999999e75Initial program 60.2%
cancel-sign-sub60.2%
cancel-sign-sub-inv60.2%
*-commutative60.2%
remove-double-neg60.2%
*-commutative60.2%
Simplified60.2%
Taylor expanded in y around 0 52.6%
Taylor expanded in a around inf 72.8%
+-commutative72.8%
mul-1-neg72.8%
unsub-neg72.8%
*-commutative72.8%
Simplified72.8%
if -5.09999999999999973e-36 < z < 1.45000000000000006e-66 or 1.7e5 < z < 2.0500000000000001e40Initial program 81.9%
cancel-sign-sub81.9%
cancel-sign-sub-inv81.9%
*-commutative81.9%
remove-double-neg81.9%
*-commutative81.9%
Simplified81.9%
Taylor expanded in i around inf 58.6%
sub-neg58.6%
mul-1-neg58.6%
remove-double-neg58.6%
+-commutative58.6%
mul-1-neg58.6%
unsub-neg58.6%
*-commutative58.6%
Simplified58.6%
if 1.45000000000000006e-66 < z < 1.7e5Initial program 63.5%
cancel-sign-sub63.5%
cancel-sign-sub-inv63.5%
*-commutative63.5%
remove-double-neg63.5%
*-commutative63.5%
Simplified63.5%
Taylor expanded in c around inf 64.5%
*-commutative64.5%
Simplified64.5%
if 2.6499999999999999e75 < z < 3.99999999999999971e75Initial program 100.0%
cancel-sign-sub100.0%
cancel-sign-sub-inv100.0%
*-commutative100.0%
remove-double-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in t around inf 100.0%
*-commutative100.0%
associate-*r*100.0%
neg-mul-1100.0%
cancel-sign-sub100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
Simplified100.0%
Taylor expanded in i around inf 100.0%
Final simplification67.7%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= t -5.8e+105) (not (<= t 1.38e+163))) (* t (- (* b i) (* x a))) (+ (* y (- (* x z) (* i j))) (* c (- (* a j) (* z b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((t <= -5.8e+105) || !(t <= 1.38e+163)) {
tmp = t * ((b * i) - (x * a));
} else {
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)));
}
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 <= (-5.8d+105)) .or. (.not. (t <= 1.38d+163))) then
tmp = t * ((b * i) - (x * a))
else
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)))
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 <= -5.8e+105) || !(t <= 1.38e+163)) {
tmp = t * ((b * i) - (x * a));
} else {
tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (t <= -5.8e+105) or not (t <= 1.38e+163): tmp = t * ((b * i) - (x * a)) else: tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((t <= -5.8e+105) || !(t <= 1.38e+163)) tmp = Float64(t * Float64(Float64(b * i) - Float64(x * a))); else tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(c * Float64(Float64(a * j) - Float64(z * b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((t <= -5.8e+105) || ~((t <= 1.38e+163))) tmp = t * ((b * i) - (x * a)); else tmp = (y * ((x * z) - (i * j))) + (c * ((a * j) - (z * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[t, -5.8e+105], N[Not[LessEqual[t, 1.38e+163]], $MachinePrecision]], N[(t * N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -5.8 \cdot 10^{+105} \lor \neg \left(t \leq 1.38 \cdot 10^{+163}\right):\\
\;\;\;\;t \cdot \left(b \cdot i - x \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + c \cdot \left(a \cdot j - z \cdot b\right)\\
\end{array}
\end{array}
if t < -5.8000000000000002e105 or 1.38000000000000004e163 < t Initial program 56.0%
cancel-sign-sub56.0%
cancel-sign-sub-inv56.0%
*-commutative56.0%
remove-double-neg56.0%
*-commutative56.0%
Simplified56.0%
Taylor expanded in t around inf 72.0%
*-commutative72.0%
associate-*r*72.0%
neg-mul-172.0%
cancel-sign-sub72.0%
+-commutative72.0%
mul-1-neg72.0%
unsub-neg72.0%
Simplified72.0%
if -5.8000000000000002e105 < t < 1.38000000000000004e163Initial program 83.5%
cancel-sign-sub83.5%
cancel-sign-sub-inv83.5%
*-commutative83.5%
remove-double-neg83.5%
*-commutative83.5%
Simplified83.5%
Taylor expanded in y around 0 80.3%
Taylor expanded in t around 0 64.2%
sub-neg64.2%
+-commutative64.2%
+-commutative64.2%
associate-+r+64.2%
*-commutative64.2%
*-commutative64.2%
mul-1-neg64.2%
*-commutative64.2%
associate-*r*65.8%
distribute-rgt-neg-in65.8%
*-commutative65.8%
distribute-lft-in67.4%
+-commutative67.4%
sub-neg67.4%
Simplified69.1%
Final simplification69.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* t b) (* y j))))
(t_2 (* a (- (* c j) (* x t))))
(t_3 (* z (- (* x y) (* b c)))))
(if (<= z -7.1e+44)
t_3
(if (<= z -3.8e-35)
t_2
(if (<= z 1.7e-65)
t_1
(if (<= z 12.0)
(* x (- (* y z) (* t a)))
(if (<= z 1.1e+56) t_1 (if (<= z 4e+75) t_2 t_3))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((t * b) - (y * j));
double t_2 = a * ((c * j) - (x * t));
double t_3 = z * ((x * y) - (b * c));
double tmp;
if (z <= -7.1e+44) {
tmp = t_3;
} else if (z <= -3.8e-35) {
tmp = t_2;
} else if (z <= 1.7e-65) {
tmp = t_1;
} else if (z <= 12.0) {
tmp = x * ((y * z) - (t * a));
} else if (z <= 1.1e+56) {
tmp = t_1;
} else if (z <= 4e+75) {
tmp = t_2;
} else {
tmp = t_3;
}
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) :: t_3
real(8) :: tmp
t_1 = i * ((t * b) - (y * j))
t_2 = a * ((c * j) - (x * t))
t_3 = z * ((x * y) - (b * c))
if (z <= (-7.1d+44)) then
tmp = t_3
else if (z <= (-3.8d-35)) then
tmp = t_2
else if (z <= 1.7d-65) then
tmp = t_1
else if (z <= 12.0d0) then
tmp = x * ((y * z) - (t * a))
else if (z <= 1.1d+56) then
tmp = t_1
else if (z <= 4d+75) then
tmp = t_2
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((t * b) - (y * j));
double t_2 = a * ((c * j) - (x * t));
double t_3 = z * ((x * y) - (b * c));
double tmp;
if (z <= -7.1e+44) {
tmp = t_3;
} else if (z <= -3.8e-35) {
tmp = t_2;
} else if (z <= 1.7e-65) {
tmp = t_1;
} else if (z <= 12.0) {
tmp = x * ((y * z) - (t * a));
} else if (z <= 1.1e+56) {
tmp = t_1;
} else if (z <= 4e+75) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((t * b) - (y * j)) t_2 = a * ((c * j) - (x * t)) t_3 = z * ((x * y) - (b * c)) tmp = 0 if z <= -7.1e+44: tmp = t_3 elif z <= -3.8e-35: tmp = t_2 elif z <= 1.7e-65: tmp = t_1 elif z <= 12.0: tmp = x * ((y * z) - (t * a)) elif z <= 1.1e+56: tmp = t_1 elif z <= 4e+75: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(t * b) - Float64(y * j))) t_2 = Float64(a * Float64(Float64(c * j) - Float64(x * t))) t_3 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -7.1e+44) tmp = t_3; elseif (z <= -3.8e-35) tmp = t_2; elseif (z <= 1.7e-65) tmp = t_1; elseif (z <= 12.0) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (z <= 1.1e+56) tmp = t_1; elseif (z <= 4e+75) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * ((t * b) - (y * j)); t_2 = a * ((c * j) - (x * t)); t_3 = z * ((x * y) - (b * c)); tmp = 0.0; if (z <= -7.1e+44) tmp = t_3; elseif (z <= -3.8e-35) tmp = t_2; elseif (z <= 1.7e-65) tmp = t_1; elseif (z <= 12.0) tmp = x * ((y * z) - (t * a)); elseif (z <= 1.1e+56) tmp = t_1; elseif (z <= 4e+75) tmp = t_2; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(N[(t * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.1e+44], t$95$3, If[LessEqual[z, -3.8e-35], t$95$2, If[LessEqual[z, 1.7e-65], t$95$1, If[LessEqual[z, 12.0], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e+56], t$95$1, If[LessEqual[z, 4e+75], t$95$2, t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(t \cdot b - y \cdot j\right)\\
t_2 := a \cdot \left(c \cdot j - x \cdot t\right)\\
t_3 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -7.1 \cdot 10^{+44}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-35}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-65}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 12:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+56}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+75}:\\
\;\;\;\;t_2\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if z < -7.0999999999999999e44 or 3.99999999999999971e75 < z Initial program 73.2%
cancel-sign-sub73.2%
cancel-sign-sub-inv73.2%
*-commutative73.2%
remove-double-neg73.2%
*-commutative73.2%
Simplified73.2%
Taylor expanded in z around inf 76.8%
if -7.0999999999999999e44 < z < -3.8000000000000001e-35 or 1.10000000000000008e56 < z < 3.99999999999999971e75Initial program 61.7%
cancel-sign-sub61.7%
cancel-sign-sub-inv61.7%
*-commutative61.7%
remove-double-neg61.7%
*-commutative61.7%
Simplified61.7%
Taylor expanded in y around 0 54.4%
Taylor expanded in a around inf 70.1%
+-commutative70.1%
mul-1-neg70.1%
unsub-neg70.1%
*-commutative70.1%
Simplified70.1%
if -3.8000000000000001e-35 < z < 1.69999999999999993e-65 or 12 < z < 1.10000000000000008e56Initial program 82.1%
cancel-sign-sub82.1%
cancel-sign-sub-inv82.1%
*-commutative82.1%
remove-double-neg82.1%
*-commutative82.1%
Simplified82.1%
Taylor expanded in i around inf 58.1%
sub-neg58.1%
mul-1-neg58.1%
remove-double-neg58.1%
+-commutative58.1%
mul-1-neg58.1%
unsub-neg58.1%
*-commutative58.1%
Simplified58.1%
if 1.69999999999999993e-65 < z < 12Initial program 59.8%
cancel-sign-sub59.8%
cancel-sign-sub-inv59.8%
*-commutative59.8%
remove-double-neg59.8%
*-commutative59.8%
Simplified59.8%
Taylor expanded in x around inf 80.2%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* c j) (* x t)))) (t_2 (* z (- (* x y) (* b c)))))
(if (<= z -1.55e+39)
t_2
(if (<= z -1.4e-36)
t_1
(if (<= z 3.8e-65)
(- (* i (* t b)) (* i (* y j)))
(if (<= z 52.0)
(* x (- (* y z) (* t a)))
(if (<= z 8.5e+47)
(* i (- (* t b) (* y j)))
(if (<= z 5.5e+75) 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 = a * ((c * j) - (x * t));
double t_2 = z * ((x * y) - (b * c));
double tmp;
if (z <= -1.55e+39) {
tmp = t_2;
} else if (z <= -1.4e-36) {
tmp = t_1;
} else if (z <= 3.8e-65) {
tmp = (i * (t * b)) - (i * (y * j));
} else if (z <= 52.0) {
tmp = x * ((y * z) - (t * a));
} else if (z <= 8.5e+47) {
tmp = i * ((t * b) - (y * j));
} else if (z <= 5.5e+75) {
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 = a * ((c * j) - (x * t))
t_2 = z * ((x * y) - (b * c))
if (z <= (-1.55d+39)) then
tmp = t_2
else if (z <= (-1.4d-36)) then
tmp = t_1
else if (z <= 3.8d-65) then
tmp = (i * (t * b)) - (i * (y * j))
else if (z <= 52.0d0) then
tmp = x * ((y * z) - (t * a))
else if (z <= 8.5d+47) then
tmp = i * ((t * b) - (y * j))
else if (z <= 5.5d+75) 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 = a * ((c * j) - (x * t));
double t_2 = z * ((x * y) - (b * c));
double tmp;
if (z <= -1.55e+39) {
tmp = t_2;
} else if (z <= -1.4e-36) {
tmp = t_1;
} else if (z <= 3.8e-65) {
tmp = (i * (t * b)) - (i * (y * j));
} else if (z <= 52.0) {
tmp = x * ((y * z) - (t * a));
} else if (z <= 8.5e+47) {
tmp = i * ((t * b) - (y * j));
} else if (z <= 5.5e+75) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((c * j) - (x * t)) t_2 = z * ((x * y) - (b * c)) tmp = 0 if z <= -1.55e+39: tmp = t_2 elif z <= -1.4e-36: tmp = t_1 elif z <= 3.8e-65: tmp = (i * (t * b)) - (i * (y * j)) elif z <= 52.0: tmp = x * ((y * z) - (t * a)) elif z <= 8.5e+47: tmp = i * ((t * b) - (y * j)) elif z <= 5.5e+75: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(c * j) - Float64(x * t))) t_2 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -1.55e+39) tmp = t_2; elseif (z <= -1.4e-36) tmp = t_1; elseif (z <= 3.8e-65) tmp = Float64(Float64(i * Float64(t * b)) - Float64(i * Float64(y * j))); elseif (z <= 52.0) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (z <= 8.5e+47) tmp = Float64(i * Float64(Float64(t * b) - Float64(y * j))); elseif (z <= 5.5e+75) 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 = a * ((c * j) - (x * t)); t_2 = z * ((x * y) - (b * c)); tmp = 0.0; if (z <= -1.55e+39) tmp = t_2; elseif (z <= -1.4e-36) tmp = t_1; elseif (z <= 3.8e-65) tmp = (i * (t * b)) - (i * (y * j)); elseif (z <= 52.0) tmp = x * ((y * z) - (t * a)); elseif (z <= 8.5e+47) tmp = i * ((t * b) - (y * j)); elseif (z <= 5.5e+75) 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[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.55e+39], t$95$2, If[LessEqual[z, -1.4e-36], t$95$1, If[LessEqual[z, 3.8e-65], N[(N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 52.0], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e+47], N[(i * N[(N[(t * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e+75], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(c \cdot j - x \cdot t\right)\\
t_2 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -1.55 \cdot 10^{+39}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -1.4 \cdot 10^{-36}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 3.8 \cdot 10^{-65}:\\
\;\;\;\;i \cdot \left(t \cdot b\right) - i \cdot \left(y \cdot j\right)\\
\mathbf{elif}\;z \leq 52:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{+47}:\\
\;\;\;\;i \cdot \left(t \cdot b - y \cdot j\right)\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{+75}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -1.5500000000000001e39 or 5.5000000000000001e75 < z Initial program 73.2%
cancel-sign-sub73.2%
cancel-sign-sub-inv73.2%
*-commutative73.2%
remove-double-neg73.2%
*-commutative73.2%
Simplified73.2%
Taylor expanded in z around inf 76.8%
if -1.5500000000000001e39 < z < -1.4000000000000001e-36 or 8.5000000000000008e47 < z < 5.5000000000000001e75Initial program 61.7%
cancel-sign-sub61.7%
cancel-sign-sub-inv61.7%
*-commutative61.7%
remove-double-neg61.7%
*-commutative61.7%
Simplified61.7%
Taylor expanded in y around 0 54.4%
Taylor expanded in a around inf 70.1%
+-commutative70.1%
mul-1-neg70.1%
unsub-neg70.1%
*-commutative70.1%
Simplified70.1%
if -1.4000000000000001e-36 < z < 3.8000000000000002e-65Initial program 82.8%
+-commutative82.8%
fma-def82.8%
*-commutative82.8%
*-commutative82.8%
Simplified82.8%
Taylor expanded in a around 0 62.4%
Taylor expanded in z around 0 56.4%
distribute-lft-out--56.4%
*-commutative56.4%
Simplified56.4%
if 3.8000000000000002e-65 < z < 52Initial program 59.8%
cancel-sign-sub59.8%
cancel-sign-sub-inv59.8%
*-commutative59.8%
remove-double-neg59.8%
*-commutative59.8%
Simplified59.8%
Taylor expanded in x around inf 80.2%
if 52 < z < 8.5000000000000008e47Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in i around inf 85.9%
sub-neg85.9%
mul-1-neg85.9%
remove-double-neg85.9%
+-commutative85.9%
mul-1-neg85.9%
unsub-neg85.9%
*-commutative85.9%
Simplified85.9%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* x (* y z)) (* b (- (* z c) (* t i))))))
(if (<= z -9.5e+39)
t_1
(if (<= z -2.2e-36)
(* a (- (* c j) (* x t)))
(if (<= z 4.5e-134) (- (* i (* t b)) (* y (* i 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 = (x * (y * z)) - (b * ((z * c) - (t * i)));
double tmp;
if (z <= -9.5e+39) {
tmp = t_1;
} else if (z <= -2.2e-36) {
tmp = a * ((c * j) - (x * t));
} else if (z <= 4.5e-134) {
tmp = (i * (t * b)) - (y * (i * 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 = (x * (y * z)) - (b * ((z * c) - (t * i)))
if (z <= (-9.5d+39)) then
tmp = t_1
else if (z <= (-2.2d-36)) then
tmp = a * ((c * j) - (x * t))
else if (z <= 4.5d-134) then
tmp = (i * (t * b)) - (y * (i * 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 = (x * (y * z)) - (b * ((z * c) - (t * i)));
double tmp;
if (z <= -9.5e+39) {
tmp = t_1;
} else if (z <= -2.2e-36) {
tmp = a * ((c * j) - (x * t));
} else if (z <= 4.5e-134) {
tmp = (i * (t * b)) - (y * (i * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (x * (y * z)) - (b * ((z * c) - (t * i))) tmp = 0 if z <= -9.5e+39: tmp = t_1 elif z <= -2.2e-36: tmp = a * ((c * j) - (x * t)) elif z <= 4.5e-134: tmp = (i * (t * b)) - (y * (i * j)) else: tmp = t_1 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(z * c) - Float64(t * i)))) tmp = 0.0 if (z <= -9.5e+39) tmp = t_1; elseif (z <= -2.2e-36) tmp = Float64(a * Float64(Float64(c * j) - Float64(x * t))); elseif (z <= 4.5e-134) tmp = Float64(Float64(i * Float64(t * b)) - Float64(y * Float64(i * j))); 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)) - (b * ((z * c) - (t * i))); tmp = 0.0; if (z <= -9.5e+39) tmp = t_1; elseif (z <= -2.2e-36) tmp = a * ((c * j) - (x * t)); elseif (z <= 4.5e-134) tmp = (i * (t * b)) - (y * (i * j)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(z * c), $MachinePrecision] - N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -9.5e+39], t$95$1, If[LessEqual[z, -2.2e-36], N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.5e-134], N[(N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision] - N[(y * N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right) - b \cdot \left(z \cdot c - t \cdot i\right)\\
\mathbf{if}\;z \leq -9.5 \cdot 10^{+39}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.2 \cdot 10^{-36}:\\
\;\;\;\;a \cdot \left(c \cdot j - x \cdot t\right)\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{-134}:\\
\;\;\;\;i \cdot \left(t \cdot b\right) - y \cdot \left(i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -9.50000000000000011e39 or 4.5000000000000005e-134 < z Initial program 72.5%
cancel-sign-sub72.5%
cancel-sign-sub-inv72.5%
*-commutative72.5%
remove-double-neg72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in j around 0 74.8%
Taylor expanded in y around inf 72.1%
if -9.50000000000000011e39 < z < -2.1999999999999999e-36Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in y around 0 63.6%
Taylor expanded in a around inf 69.4%
+-commutative69.4%
mul-1-neg69.4%
unsub-neg69.4%
*-commutative69.4%
Simplified69.4%
if -2.1999999999999999e-36 < z < 4.5000000000000005e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in i around inf 55.3%
sub-neg55.3%
mul-1-neg55.3%
remove-double-neg55.3%
+-commutative55.3%
mul-1-neg55.3%
unsub-neg55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in t around 0 59.4%
Final simplification67.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* c j) (* x t)))))
(if (<= t -3.6e+187)
t_1
(if (<= t -4.2e+109)
(* b (* t i))
(if (<= t -1.15e+59)
t_1
(if (<= t -7.4e-13)
(* i (* t b))
(if (<= t 1.25e+163) (* c (- (* a 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 = a * ((c * j) - (x * t));
double tmp;
if (t <= -3.6e+187) {
tmp = t_1;
} else if (t <= -4.2e+109) {
tmp = b * (t * i);
} else if (t <= -1.15e+59) {
tmp = t_1;
} else if (t <= -7.4e-13) {
tmp = i * (t * b);
} else if (t <= 1.25e+163) {
tmp = c * ((a * 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 = a * ((c * j) - (x * t))
if (t <= (-3.6d+187)) then
tmp = t_1
else if (t <= (-4.2d+109)) then
tmp = b * (t * i)
else if (t <= (-1.15d+59)) then
tmp = t_1
else if (t <= (-7.4d-13)) then
tmp = i * (t * b)
else if (t <= 1.25d+163) then
tmp = c * ((a * 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 = a * ((c * j) - (x * t));
double tmp;
if (t <= -3.6e+187) {
tmp = t_1;
} else if (t <= -4.2e+109) {
tmp = b * (t * i);
} else if (t <= -1.15e+59) {
tmp = t_1;
} else if (t <= -7.4e-13) {
tmp = i * (t * b);
} else if (t <= 1.25e+163) {
tmp = c * ((a * j) - (z * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((c * j) - (x * t)) tmp = 0 if t <= -3.6e+187: tmp = t_1 elif t <= -4.2e+109: tmp = b * (t * i) elif t <= -1.15e+59: tmp = t_1 elif t <= -7.4e-13: tmp = i * (t * b) elif t <= 1.25e+163: tmp = c * ((a * j) - (z * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(c * j) - Float64(x * t))) tmp = 0.0 if (t <= -3.6e+187) tmp = t_1; elseif (t <= -4.2e+109) tmp = Float64(b * Float64(t * i)); elseif (t <= -1.15e+59) tmp = t_1; elseif (t <= -7.4e-13) tmp = Float64(i * Float64(t * b)); elseif (t <= 1.25e+163) tmp = Float64(c * Float64(Float64(a * 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 = a * ((c * j) - (x * t)); tmp = 0.0; if (t <= -3.6e+187) tmp = t_1; elseif (t <= -4.2e+109) tmp = b * (t * i); elseif (t <= -1.15e+59) tmp = t_1; elseif (t <= -7.4e-13) tmp = i * (t * b); elseif (t <= 1.25e+163) tmp = c * ((a * 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[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.6e+187], t$95$1, If[LessEqual[t, -4.2e+109], N[(b * N[(t * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -1.15e+59], t$95$1, If[LessEqual[t, -7.4e-13], N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.25e+163], N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(c \cdot j - x \cdot t\right)\\
\mathbf{if}\;t \leq -3.6 \cdot 10^{+187}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -4.2 \cdot 10^{+109}:\\
\;\;\;\;b \cdot \left(t \cdot i\right)\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{+59}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -7.4 \cdot 10^{-13}:\\
\;\;\;\;i \cdot \left(t \cdot b\right)\\
\mathbf{elif}\;t \leq 1.25 \cdot 10^{+163}:\\
\;\;\;\;c \cdot \left(a \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if t < -3.60000000000000036e187 or -4.2000000000000003e109 < t < -1.15000000000000004e59 or 1.25e163 < t Initial program 57.2%
cancel-sign-sub57.2%
cancel-sign-sub-inv57.2%
*-commutative57.2%
remove-double-neg57.2%
*-commutative57.2%
Simplified57.2%
Taylor expanded in y around 0 63.2%
Taylor expanded in a around inf 59.3%
+-commutative59.3%
mul-1-neg59.3%
unsub-neg59.3%
*-commutative59.3%
Simplified59.3%
if -3.60000000000000036e187 < t < -4.2000000000000003e109Initial program 59.4%
cancel-sign-sub59.4%
cancel-sign-sub-inv59.4%
*-commutative59.4%
remove-double-neg59.4%
*-commutative59.4%
Simplified59.4%
Taylor expanded in j around 0 59.5%
Taylor expanded in i around inf 54.1%
associate-*r*65.3%
Simplified65.3%
if -1.15000000000000004e59 < t < -7.39999999999999977e-13Initial program 100.0%
cancel-sign-sub100.0%
cancel-sign-sub-inv100.0%
*-commutative100.0%
remove-double-neg100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in j around 0 80.8%
Taylor expanded in i around inf 47.8%
if -7.39999999999999977e-13 < t < 1.25e163Initial program 82.8%
cancel-sign-sub82.8%
cancel-sign-sub-inv82.8%
*-commutative82.8%
remove-double-neg82.8%
*-commutative82.8%
Simplified82.8%
Taylor expanded in c around inf 49.8%
*-commutative49.8%
Simplified49.8%
Final simplification53.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* a j) (* z b)))) (t_2 (* i (- (* t b) (* y j)))))
(if (<= i -4.2e-58)
t_2
(if (<= i 8.8e-73)
t_1
(if (<= i 24500000000000.0)
t_2
(if (<= i 1.15e+148) t_1 (if (<= i 3.8e+229) (* b (* t i)) 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 = c * ((a * j) - (z * b));
double t_2 = i * ((t * b) - (y * j));
double tmp;
if (i <= -4.2e-58) {
tmp = t_2;
} else if (i <= 8.8e-73) {
tmp = t_1;
} else if (i <= 24500000000000.0) {
tmp = t_2;
} else if (i <= 1.15e+148) {
tmp = t_1;
} else if (i <= 3.8e+229) {
tmp = b * (t * i);
} 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 = c * ((a * j) - (z * b))
t_2 = i * ((t * b) - (y * j))
if (i <= (-4.2d-58)) then
tmp = t_2
else if (i <= 8.8d-73) then
tmp = t_1
else if (i <= 24500000000000.0d0) then
tmp = t_2
else if (i <= 1.15d+148) then
tmp = t_1
else if (i <= 3.8d+229) then
tmp = b * (t * i)
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 = c * ((a * j) - (z * b));
double t_2 = i * ((t * b) - (y * j));
double tmp;
if (i <= -4.2e-58) {
tmp = t_2;
} else if (i <= 8.8e-73) {
tmp = t_1;
} else if (i <= 24500000000000.0) {
tmp = t_2;
} else if (i <= 1.15e+148) {
tmp = t_1;
} else if (i <= 3.8e+229) {
tmp = b * (t * i);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((a * j) - (z * b)) t_2 = i * ((t * b) - (y * j)) tmp = 0 if i <= -4.2e-58: tmp = t_2 elif i <= 8.8e-73: tmp = t_1 elif i <= 24500000000000.0: tmp = t_2 elif i <= 1.15e+148: tmp = t_1 elif i <= 3.8e+229: tmp = b * (t * i) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(a * j) - Float64(z * b))) t_2 = Float64(i * Float64(Float64(t * b) - Float64(y * j))) tmp = 0.0 if (i <= -4.2e-58) tmp = t_2; elseif (i <= 8.8e-73) tmp = t_1; elseif (i <= 24500000000000.0) tmp = t_2; elseif (i <= 1.15e+148) tmp = t_1; elseif (i <= 3.8e+229) tmp = Float64(b * Float64(t * i)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((a * j) - (z * b)); t_2 = i * ((t * b) - (y * j)); tmp = 0.0; if (i <= -4.2e-58) tmp = t_2; elseif (i <= 8.8e-73) tmp = t_1; elseif (i <= 24500000000000.0) tmp = t_2; elseif (i <= 1.15e+148) tmp = t_1; elseif (i <= 3.8e+229) tmp = b * (t * i); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(a * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(t * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -4.2e-58], t$95$2, If[LessEqual[i, 8.8e-73], t$95$1, If[LessEqual[i, 24500000000000.0], t$95$2, If[LessEqual[i, 1.15e+148], t$95$1, If[LessEqual[i, 3.8e+229], N[(b * N[(t * i), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(a \cdot j - z \cdot b\right)\\
t_2 := i \cdot \left(t \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -4.2 \cdot 10^{-58}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;i \leq 8.8 \cdot 10^{-73}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 24500000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;i \leq 1.15 \cdot 10^{+148}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 3.8 \cdot 10^{+229}:\\
\;\;\;\;b \cdot \left(t \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if i < -4.19999999999999975e-58 or 8.8000000000000001e-73 < i < 2.45e13 or 3.80000000000000018e229 < i Initial program 69.6%
cancel-sign-sub69.6%
cancel-sign-sub-inv69.6%
*-commutative69.6%
remove-double-neg69.6%
*-commutative69.6%
Simplified69.6%
Taylor expanded in i around inf 63.6%
sub-neg63.6%
mul-1-neg63.6%
remove-double-neg63.6%
+-commutative63.6%
mul-1-neg63.6%
unsub-neg63.6%
*-commutative63.6%
Simplified63.6%
if -4.19999999999999975e-58 < i < 8.8000000000000001e-73 or 2.45e13 < i < 1.15e148Initial program 82.1%
cancel-sign-sub82.1%
cancel-sign-sub-inv82.1%
*-commutative82.1%
remove-double-neg82.1%
*-commutative82.1%
Simplified82.1%
Taylor expanded in c around inf 53.2%
*-commutative53.2%
Simplified53.2%
if 1.15e148 < i < 3.80000000000000018e229Initial program 58.2%
cancel-sign-sub58.2%
cancel-sign-sub-inv58.2%
*-commutative58.2%
remove-double-neg58.2%
*-commutative58.2%
Simplified58.2%
Taylor expanded in j around 0 84.2%
Taylor expanded in i around inf 61.0%
associate-*r*69.1%
Simplified69.1%
Final simplification58.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (- (* x y) (* b c)))))
(if (<= z -2.35e+41)
t_1
(if (<= z -2.7e-36)
(* a (- (* c j) (* x t)))
(if (<= z 1.65e-134)
(- (* i (* t b)) (* y (* i j)))
(if (<= z 4e+75) (* t (- (* b i) (* x a))) 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) - (b * c));
double tmp;
if (z <= -2.35e+41) {
tmp = t_1;
} else if (z <= -2.7e-36) {
tmp = a * ((c * j) - (x * t));
} else if (z <= 1.65e-134) {
tmp = (i * (t * b)) - (y * (i * j));
} else if (z <= 4e+75) {
tmp = t * ((b * i) - (x * a));
} 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) - (b * c))
if (z <= (-2.35d+41)) then
tmp = t_1
else if (z <= (-2.7d-36)) then
tmp = a * ((c * j) - (x * t))
else if (z <= 1.65d-134) then
tmp = (i * (t * b)) - (y * (i * j))
else if (z <= 4d+75) then
tmp = t * ((b * i) - (x * a))
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) - (b * c));
double tmp;
if (z <= -2.35e+41) {
tmp = t_1;
} else if (z <= -2.7e-36) {
tmp = a * ((c * j) - (x * t));
} else if (z <= 1.65e-134) {
tmp = (i * (t * b)) - (y * (i * j));
} else if (z <= 4e+75) {
tmp = t * ((b * i) - (x * a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * ((x * y) - (b * c)) tmp = 0 if z <= -2.35e+41: tmp = t_1 elif z <= -2.7e-36: tmp = a * ((c * j) - (x * t)) elif z <= 1.65e-134: tmp = (i * (t * b)) - (y * (i * j)) elif z <= 4e+75: tmp = t * ((b * i) - (x * a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -2.35e+41) tmp = t_1; elseif (z <= -2.7e-36) tmp = Float64(a * Float64(Float64(c * j) - Float64(x * t))); elseif (z <= 1.65e-134) tmp = Float64(Float64(i * Float64(t * b)) - Float64(y * Float64(i * j))); elseif (z <= 4e+75) tmp = Float64(t * Float64(Float64(b * i) - Float64(x * a))); 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) - (b * c)); tmp = 0.0; if (z <= -2.35e+41) tmp = t_1; elseif (z <= -2.7e-36) tmp = a * ((c * j) - (x * t)); elseif (z <= 1.65e-134) tmp = (i * (t * b)) - (y * (i * j)); elseif (z <= 4e+75) tmp = t * ((b * i) - (x * a)); 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[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.35e+41], t$95$1, If[LessEqual[z, -2.7e-36], N[(a * N[(N[(c * j), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.65e-134], N[(N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision] - N[(y * N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+75], N[(t * N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -2.35 \cdot 10^{+41}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-36}:\\
\;\;\;\;a \cdot \left(c \cdot j - x \cdot t\right)\\
\mathbf{elif}\;z \leq 1.65 \cdot 10^{-134}:\\
\;\;\;\;i \cdot \left(t \cdot b\right) - y \cdot \left(i \cdot j\right)\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+75}:\\
\;\;\;\;t \cdot \left(b \cdot i - x \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -2.35e41 or 3.99999999999999971e75 < z Initial program 73.2%
cancel-sign-sub73.2%
cancel-sign-sub-inv73.2%
*-commutative73.2%
remove-double-neg73.2%
*-commutative73.2%
Simplified73.2%
Taylor expanded in z around inf 76.8%
if -2.35e41 < z < -2.70000000000000007e-36Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in y around 0 63.6%
Taylor expanded in a around inf 69.4%
+-commutative69.4%
mul-1-neg69.4%
unsub-neg69.4%
*-commutative69.4%
Simplified69.4%
if -2.70000000000000007e-36 < z < 1.6500000000000001e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in i around inf 55.3%
sub-neg55.3%
mul-1-neg55.3%
remove-double-neg55.3%
+-commutative55.3%
mul-1-neg55.3%
unsub-neg55.3%
*-commutative55.3%
Simplified55.3%
Taylor expanded in t around 0 59.4%
if 1.6500000000000001e-134 < z < 3.99999999999999971e75Initial program 70.8%
cancel-sign-sub70.8%
cancel-sign-sub-inv70.8%
*-commutative70.8%
remove-double-neg70.8%
*-commutative70.8%
Simplified70.8%
Taylor expanded in t around inf 62.0%
*-commutative62.0%
associate-*r*62.0%
neg-mul-162.0%
cancel-sign-sub62.0%
+-commutative62.0%
mul-1-neg62.0%
unsub-neg62.0%
Simplified62.0%
Final simplification67.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* x z))))
(if (<= z -3.15e+38)
t_1
(if (<= z -2.8e-38)
(* t (* x (- a)))
(if (<= z 3.5e-282)
(* i (* t b))
(if (<= z 1.45e-135)
(* c (* a j))
(if (<= z 4e+122) (* t (* b 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 = y * (x * z);
double tmp;
if (z <= -3.15e+38) {
tmp = t_1;
} else if (z <= -2.8e-38) {
tmp = t * (x * -a);
} else if (z <= 3.5e-282) {
tmp = i * (t * b);
} else if (z <= 1.45e-135) {
tmp = c * (a * j);
} else if (z <= 4e+122) {
tmp = t * (b * 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 = y * (x * z)
if (z <= (-3.15d+38)) then
tmp = t_1
else if (z <= (-2.8d-38)) then
tmp = t * (x * -a)
else if (z <= 3.5d-282) then
tmp = i * (t * b)
else if (z <= 1.45d-135) then
tmp = c * (a * j)
else if (z <= 4d+122) then
tmp = t * (b * 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 = y * (x * z);
double tmp;
if (z <= -3.15e+38) {
tmp = t_1;
} else if (z <= -2.8e-38) {
tmp = t * (x * -a);
} else if (z <= 3.5e-282) {
tmp = i * (t * b);
} else if (z <= 1.45e-135) {
tmp = c * (a * j);
} else if (z <= 4e+122) {
tmp = t * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (x * z) tmp = 0 if z <= -3.15e+38: tmp = t_1 elif z <= -2.8e-38: tmp = t * (x * -a) elif z <= 3.5e-282: tmp = i * (t * b) elif z <= 1.45e-135: tmp = c * (a * j) elif z <= 4e+122: tmp = t * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(x * z)) tmp = 0.0 if (z <= -3.15e+38) tmp = t_1; elseif (z <= -2.8e-38) tmp = Float64(t * Float64(x * Float64(-a))); elseif (z <= 3.5e-282) tmp = Float64(i * Float64(t * b)); elseif (z <= 1.45e-135) tmp = Float64(c * Float64(a * j)); elseif (z <= 4e+122) tmp = Float64(t * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * (x * z); tmp = 0.0; if (z <= -3.15e+38) tmp = t_1; elseif (z <= -2.8e-38) tmp = t * (x * -a); elseif (z <= 3.5e-282) tmp = i * (t * b); elseif (z <= 1.45e-135) tmp = c * (a * j); elseif (z <= 4e+122) tmp = t * (b * 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[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.15e+38], t$95$1, If[LessEqual[z, -2.8e-38], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.5e-282], N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.45e-135], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+122], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z\right)\\
\mathbf{if}\;z \leq -3.15 \cdot 10^{+38}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.8 \cdot 10^{-38}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;z \leq 3.5 \cdot 10^{-282}:\\
\;\;\;\;i \cdot \left(t \cdot b\right)\\
\mathbf{elif}\;z \leq 1.45 \cdot 10^{-135}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+122}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -3.15000000000000001e38 or 4.00000000000000006e122 < z Initial program 71.5%
cancel-sign-sub71.5%
cancel-sign-sub-inv71.5%
*-commutative71.5%
remove-double-neg71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in y around inf 51.7%
*-commutative51.7%
mul-1-neg51.7%
unsub-neg51.7%
Simplified51.7%
Taylor expanded in z around inf 47.8%
if -3.15000000000000001e38 < z < -2.8e-38Initial program 70.0%
cancel-sign-sub70.0%
cancel-sign-sub-inv70.0%
*-commutative70.0%
remove-double-neg70.0%
*-commutative70.0%
Simplified70.0%
Taylor expanded in t around inf 41.1%
*-commutative41.1%
associate-*r*41.1%
neg-mul-141.1%
cancel-sign-sub41.1%
+-commutative41.1%
mul-1-neg41.1%
unsub-neg41.1%
Simplified41.1%
Taylor expanded in i around 0 40.9%
*-commutative40.9%
neg-mul-140.9%
distribute-lft-neg-in40.9%
Simplified40.9%
if -2.8e-38 < z < 3.50000000000000006e-282Initial program 79.0%
cancel-sign-sub79.0%
cancel-sign-sub-inv79.0%
*-commutative79.0%
remove-double-neg79.0%
*-commutative79.0%
Simplified79.0%
Taylor expanded in j around 0 49.5%
Taylor expanded in i around inf 30.1%
if 3.50000000000000006e-282 < z < 1.4500000000000001e-135Initial program 89.9%
cancel-sign-sub89.9%
cancel-sign-sub-inv89.9%
*-commutative89.9%
remove-double-neg89.9%
*-commutative89.9%
Simplified89.9%
Taylor expanded in c around inf 51.3%
*-commutative51.3%
Simplified51.3%
Taylor expanded in j around inf 41.8%
*-commutative41.8%
Simplified41.8%
if 1.4500000000000001e-135 < z < 4.00000000000000006e122Initial program 75.1%
cancel-sign-sub75.1%
cancel-sign-sub-inv75.1%
*-commutative75.1%
remove-double-neg75.1%
*-commutative75.1%
Simplified75.1%
Taylor expanded in t around inf 59.4%
*-commutative59.4%
associate-*r*59.4%
neg-mul-159.4%
cancel-sign-sub59.4%
+-commutative59.4%
mul-1-neg59.4%
unsub-neg59.4%
Simplified59.4%
Taylor expanded in i around inf 43.1%
Final simplification41.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (* t b))) (t_2 (* y (* x z))))
(if (<= x -1.3e-26)
t_2
(if (<= x -2.6e-293)
t_1
(if (<= x 9.2e-182) (* c (* a j)) (if (<= x 1.7e+34) 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 = i * (t * b);
double t_2 = y * (x * z);
double tmp;
if (x <= -1.3e-26) {
tmp = t_2;
} else if (x <= -2.6e-293) {
tmp = t_1;
} else if (x <= 9.2e-182) {
tmp = c * (a * j);
} else if (x <= 1.7e+34) {
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 = i * (t * b)
t_2 = y * (x * z)
if (x <= (-1.3d-26)) then
tmp = t_2
else if (x <= (-2.6d-293)) then
tmp = t_1
else if (x <= 9.2d-182) then
tmp = c * (a * j)
else if (x <= 1.7d+34) 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 = i * (t * b);
double t_2 = y * (x * z);
double tmp;
if (x <= -1.3e-26) {
tmp = t_2;
} else if (x <= -2.6e-293) {
tmp = t_1;
} else if (x <= 9.2e-182) {
tmp = c * (a * j);
} else if (x <= 1.7e+34) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * (t * b) t_2 = y * (x * z) tmp = 0 if x <= -1.3e-26: tmp = t_2 elif x <= -2.6e-293: tmp = t_1 elif x <= 9.2e-182: tmp = c * (a * j) elif x <= 1.7e+34: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(t * b)) t_2 = Float64(y * Float64(x * z)) tmp = 0.0 if (x <= -1.3e-26) tmp = t_2; elseif (x <= -2.6e-293) tmp = t_1; elseif (x <= 9.2e-182) tmp = Float64(c * Float64(a * j)); elseif (x <= 1.7e+34) 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 = i * (t * b); t_2 = y * (x * z); tmp = 0.0; if (x <= -1.3e-26) tmp = t_2; elseif (x <= -2.6e-293) tmp = t_1; elseif (x <= 9.2e-182) tmp = c * (a * j); elseif (x <= 1.7e+34) 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[(i * N[(t * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.3e-26], t$95$2, If[LessEqual[x, -2.6e-293], t$95$1, If[LessEqual[x, 9.2e-182], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.7e+34], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(t \cdot b\right)\\
t_2 := y \cdot \left(x \cdot z\right)\\
\mathbf{if}\;x \leq -1.3 \cdot 10^{-26}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x \leq -2.6 \cdot 10^{-293}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 9.2 \cdot 10^{-182}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{+34}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if x < -1.30000000000000005e-26 or 1.7e34 < x Initial program 72.0%
cancel-sign-sub72.0%
cancel-sign-sub-inv72.0%
*-commutative72.0%
remove-double-neg72.0%
*-commutative72.0%
Simplified72.0%
Taylor expanded in y around inf 53.4%
*-commutative53.4%
mul-1-neg53.4%
unsub-neg53.4%
Simplified53.4%
Taylor expanded in z around inf 41.2%
if -1.30000000000000005e-26 < x < -2.5999999999999998e-293 or 9.1999999999999996e-182 < x < 1.7e34Initial program 76.7%
cancel-sign-sub76.7%
cancel-sign-sub-inv76.7%
*-commutative76.7%
remove-double-neg76.7%
*-commutative76.7%
Simplified76.7%
Taylor expanded in j around 0 59.4%
Taylor expanded in i around inf 35.8%
if -2.5999999999999998e-293 < x < 9.1999999999999996e-182Initial program 84.8%
cancel-sign-sub84.8%
cancel-sign-sub-inv84.8%
*-commutative84.8%
remove-double-neg84.8%
*-commutative84.8%
Simplified84.8%
Taylor expanded in c around inf 58.9%
*-commutative58.9%
Simplified58.9%
Taylor expanded in j around inf 32.1%
*-commutative32.1%
Simplified32.1%
Final simplification37.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (* t b))))
(if (<= x -2.6e-29)
(* z (* x y))
(if (<= x -1.3e-294)
t_1
(if (<= x 1.3e-180)
(* c (* a j))
(if (<= x 1.4e+42) t_1 (* y (* x z))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * (t * b);
double tmp;
if (x <= -2.6e-29) {
tmp = z * (x * y);
} else if (x <= -1.3e-294) {
tmp = t_1;
} else if (x <= 1.3e-180) {
tmp = c * (a * j);
} else if (x <= 1.4e+42) {
tmp = t_1;
} 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) :: t_1
real(8) :: tmp
t_1 = i * (t * b)
if (x <= (-2.6d-29)) then
tmp = z * (x * y)
else if (x <= (-1.3d-294)) then
tmp = t_1
else if (x <= 1.3d-180) then
tmp = c * (a * j)
else if (x <= 1.4d+42) then
tmp = t_1
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 t_1 = i * (t * b);
double tmp;
if (x <= -2.6e-29) {
tmp = z * (x * y);
} else if (x <= -1.3e-294) {
tmp = t_1;
} else if (x <= 1.3e-180) {
tmp = c * (a * j);
} else if (x <= 1.4e+42) {
tmp = t_1;
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * (t * b) tmp = 0 if x <= -2.6e-29: tmp = z * (x * y) elif x <= -1.3e-294: tmp = t_1 elif x <= 1.3e-180: tmp = c * (a * j) elif x <= 1.4e+42: tmp = t_1 else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(t * b)) tmp = 0.0 if (x <= -2.6e-29) tmp = Float64(z * Float64(x * y)); elseif (x <= -1.3e-294) tmp = t_1; elseif (x <= 1.3e-180) tmp = Float64(c * Float64(a * j)); elseif (x <= 1.4e+42) tmp = t_1; else tmp = Float64(y * Float64(x * z)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * (t * b); tmp = 0.0; if (x <= -2.6e-29) tmp = z * (x * y); elseif (x <= -1.3e-294) tmp = t_1; elseif (x <= 1.3e-180) tmp = c * (a * j); elseif (x <= 1.4e+42) tmp = t_1; else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.6e-29], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.3e-294], t$95$1, If[LessEqual[x, 1.3e-180], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.4e+42], t$95$1, N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(t \cdot b\right)\\
\mathbf{if}\;x \leq -2.6 \cdot 10^{-29}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;x \leq -1.3 \cdot 10^{-294}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{-180}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{elif}\;x \leq 1.4 \cdot 10^{+42}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if x < -2.6000000000000002e-29Initial program 67.7%
cancel-sign-sub67.7%
cancel-sign-sub-inv67.7%
*-commutative67.7%
remove-double-neg67.7%
*-commutative67.7%
Simplified67.7%
Taylor expanded in z around inf 61.3%
Taylor expanded in y around inf 44.3%
if -2.6000000000000002e-29 < x < -1.3e-294 or 1.2999999999999999e-180 < x < 1.4e42Initial program 76.7%
cancel-sign-sub76.7%
cancel-sign-sub-inv76.7%
*-commutative76.7%
remove-double-neg76.7%
*-commutative76.7%
Simplified76.7%
Taylor expanded in j around 0 59.4%
Taylor expanded in i around inf 35.8%
if -1.3e-294 < x < 1.2999999999999999e-180Initial program 84.8%
cancel-sign-sub84.8%
cancel-sign-sub-inv84.8%
*-commutative84.8%
remove-double-neg84.8%
*-commutative84.8%
Simplified84.8%
Taylor expanded in c around inf 58.9%
*-commutative58.9%
Simplified58.9%
Taylor expanded in j around inf 32.1%
*-commutative32.1%
Simplified32.1%
if 1.4e42 < x Initial program 76.2%
cancel-sign-sub76.2%
cancel-sign-sub-inv76.2%
*-commutative76.2%
remove-double-neg76.2%
*-commutative76.2%
Simplified76.2%
Taylor expanded in y around inf 55.3%
*-commutative55.3%
mul-1-neg55.3%
unsub-neg55.3%
Simplified55.3%
Taylor expanded in z around inf 40.6%
Final simplification38.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* x z))))
(if (<= z -9.2e+40)
t_1
(if (<= z -2.5e-35)
(* t (* x (- a)))
(if (<= z 3.6e-134)
(* y (* i (- j)))
(if (<= z 3.2e+121) (* t (* b 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 = y * (x * z);
double tmp;
if (z <= -9.2e+40) {
tmp = t_1;
} else if (z <= -2.5e-35) {
tmp = t * (x * -a);
} else if (z <= 3.6e-134) {
tmp = y * (i * -j);
} else if (z <= 3.2e+121) {
tmp = t * (b * 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 = y * (x * z)
if (z <= (-9.2d+40)) then
tmp = t_1
else if (z <= (-2.5d-35)) then
tmp = t * (x * -a)
else if (z <= 3.6d-134) then
tmp = y * (i * -j)
else if (z <= 3.2d+121) then
tmp = t * (b * 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 = y * (x * z);
double tmp;
if (z <= -9.2e+40) {
tmp = t_1;
} else if (z <= -2.5e-35) {
tmp = t * (x * -a);
} else if (z <= 3.6e-134) {
tmp = y * (i * -j);
} else if (z <= 3.2e+121) {
tmp = t * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (x * z) tmp = 0 if z <= -9.2e+40: tmp = t_1 elif z <= -2.5e-35: tmp = t * (x * -a) elif z <= 3.6e-134: tmp = y * (i * -j) elif z <= 3.2e+121: tmp = t * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(x * z)) tmp = 0.0 if (z <= -9.2e+40) tmp = t_1; elseif (z <= -2.5e-35) tmp = Float64(t * Float64(x * Float64(-a))); elseif (z <= 3.6e-134) tmp = Float64(y * Float64(i * Float64(-j))); elseif (z <= 3.2e+121) tmp = Float64(t * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * (x * z); tmp = 0.0; if (z <= -9.2e+40) tmp = t_1; elseif (z <= -2.5e-35) tmp = t * (x * -a); elseif (z <= 3.6e-134) tmp = y * (i * -j); elseif (z <= 3.2e+121) tmp = t * (b * 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[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -9.2e+40], t$95$1, If[LessEqual[z, -2.5e-35], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.6e-134], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e+121], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z\right)\\
\mathbf{if}\;z \leq -9.2 \cdot 10^{+40}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -2.5 \cdot 10^{-35}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;z \leq 3.6 \cdot 10^{-134}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;z \leq 3.2 \cdot 10^{+121}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -9.19999999999999975e40 or 3.1999999999999999e121 < z Initial program 71.5%
cancel-sign-sub71.5%
cancel-sign-sub-inv71.5%
*-commutative71.5%
remove-double-neg71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in y around inf 51.7%
*-commutative51.7%
mul-1-neg51.7%
unsub-neg51.7%
Simplified51.7%
Taylor expanded in z around inf 47.8%
if -9.19999999999999975e40 < z < -2.49999999999999982e-35Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in t around inf 43.3%
*-commutative43.3%
associate-*r*43.3%
neg-mul-143.3%
cancel-sign-sub43.3%
+-commutative43.3%
mul-1-neg43.3%
unsub-neg43.3%
Simplified43.3%
Taylor expanded in i around 0 43.0%
*-commutative43.0%
neg-mul-143.0%
distribute-lft-neg-in43.0%
Simplified43.0%
if -2.49999999999999982e-35 < z < 3.5999999999999999e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in y around inf 42.4%
*-commutative42.4%
mul-1-neg42.4%
unsub-neg42.4%
Simplified42.4%
Taylor expanded in z around 0 38.1%
mul-1-neg38.1%
distribute-rgt-neg-in38.1%
*-commutative38.1%
Simplified38.1%
if 3.5999999999999999e-134 < z < 3.1999999999999999e121Initial program 74.5%
cancel-sign-sub74.5%
cancel-sign-sub-inv74.5%
*-commutative74.5%
remove-double-neg74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in t around inf 60.6%
*-commutative60.6%
associate-*r*60.6%
neg-mul-160.6%
cancel-sign-sub60.6%
+-commutative60.6%
mul-1-neg60.6%
unsub-neg60.6%
Simplified60.6%
Taylor expanded in i around inf 43.9%
Final simplification43.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* x z))))
(if (<= z -1.8e+47)
t_1
(if (<= z -1.26e-36)
(* a (* x (- t)))
(if (<= z 1.05e-134)
(* y (* i (- j)))
(if (<= z 1.26e+122) (* t (* b 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 = y * (x * z);
double tmp;
if (z <= -1.8e+47) {
tmp = t_1;
} else if (z <= -1.26e-36) {
tmp = a * (x * -t);
} else if (z <= 1.05e-134) {
tmp = y * (i * -j);
} else if (z <= 1.26e+122) {
tmp = t * (b * 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 = y * (x * z)
if (z <= (-1.8d+47)) then
tmp = t_1
else if (z <= (-1.26d-36)) then
tmp = a * (x * -t)
else if (z <= 1.05d-134) then
tmp = y * (i * -j)
else if (z <= 1.26d+122) then
tmp = t * (b * 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 = y * (x * z);
double tmp;
if (z <= -1.8e+47) {
tmp = t_1;
} else if (z <= -1.26e-36) {
tmp = a * (x * -t);
} else if (z <= 1.05e-134) {
tmp = y * (i * -j);
} else if (z <= 1.26e+122) {
tmp = t * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (x * z) tmp = 0 if z <= -1.8e+47: tmp = t_1 elif z <= -1.26e-36: tmp = a * (x * -t) elif z <= 1.05e-134: tmp = y * (i * -j) elif z <= 1.26e+122: tmp = t * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(x * z)) tmp = 0.0 if (z <= -1.8e+47) tmp = t_1; elseif (z <= -1.26e-36) tmp = Float64(a * Float64(x * Float64(-t))); elseif (z <= 1.05e-134) tmp = Float64(y * Float64(i * Float64(-j))); elseif (z <= 1.26e+122) tmp = Float64(t * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * (x * z); tmp = 0.0; if (z <= -1.8e+47) tmp = t_1; elseif (z <= -1.26e-36) tmp = a * (x * -t); elseif (z <= 1.05e-134) tmp = y * (i * -j); elseif (z <= 1.26e+122) tmp = t * (b * 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[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.8e+47], t$95$1, If[LessEqual[z, -1.26e-36], N[(a * N[(x * (-t)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.05e-134], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.26e+122], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z\right)\\
\mathbf{if}\;z \leq -1.8 \cdot 10^{+47}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq -1.26 \cdot 10^{-36}:\\
\;\;\;\;a \cdot \left(x \cdot \left(-t\right)\right)\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-134}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;z \leq 1.26 \cdot 10^{+122}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if z < -1.80000000000000004e47 or 1.25999999999999991e122 < z Initial program 71.5%
cancel-sign-sub71.5%
cancel-sign-sub-inv71.5%
*-commutative71.5%
remove-double-neg71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in y around inf 51.7%
*-commutative51.7%
mul-1-neg51.7%
unsub-neg51.7%
Simplified51.7%
Taylor expanded in z around inf 47.8%
if -1.80000000000000004e47 < z < -1.26000000000000005e-36Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in t around inf 43.3%
*-commutative43.3%
associate-*r*43.3%
neg-mul-143.3%
cancel-sign-sub43.3%
+-commutative43.3%
mul-1-neg43.3%
unsub-neg43.3%
Simplified43.3%
Taylor expanded in i around 0 43.1%
associate-*r*43.1%
neg-mul-143.1%
Simplified43.1%
if -1.26000000000000005e-36 < z < 1.05e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in y around inf 42.4%
*-commutative42.4%
mul-1-neg42.4%
unsub-neg42.4%
Simplified42.4%
Taylor expanded in z around 0 38.1%
mul-1-neg38.1%
distribute-rgt-neg-in38.1%
*-commutative38.1%
Simplified38.1%
if 1.05e-134 < z < 1.25999999999999991e122Initial program 74.5%
cancel-sign-sub74.5%
cancel-sign-sub-inv74.5%
*-commutative74.5%
remove-double-neg74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in t around inf 60.6%
*-commutative60.6%
associate-*r*60.6%
neg-mul-160.6%
cancel-sign-sub60.6%
+-commutative60.6%
mul-1-neg60.6%
unsub-neg60.6%
Simplified60.6%
Taylor expanded in i around inf 43.9%
Final simplification43.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -3.6e+51)
(* c (* z (- b)))
(if (<= z -8e-35)
(* c (* a j))
(if (<= z 1.05e-134)
(* y (* i (- j)))
(if (<= z 6.5e+120) (* t (* b i)) (* 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.6e+51) {
tmp = c * (z * -b);
} else if (z <= -8e-35) {
tmp = c * (a * j);
} else if (z <= 1.05e-134) {
tmp = y * (i * -j);
} else if (z <= 6.5e+120) {
tmp = t * (b * i);
} 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.6d+51)) then
tmp = c * (z * -b)
else if (z <= (-8d-35)) then
tmp = c * (a * j)
else if (z <= 1.05d-134) then
tmp = y * (i * -j)
else if (z <= 6.5d+120) then
tmp = t * (b * i)
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.6e+51) {
tmp = c * (z * -b);
} else if (z <= -8e-35) {
tmp = c * (a * j);
} else if (z <= 1.05e-134) {
tmp = y * (i * -j);
} else if (z <= 6.5e+120) {
tmp = t * (b * i);
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -3.6e+51: tmp = c * (z * -b) elif z <= -8e-35: tmp = c * (a * j) elif z <= 1.05e-134: tmp = y * (i * -j) elif z <= 6.5e+120: tmp = t * (b * i) else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -3.6e+51) tmp = Float64(c * Float64(z * Float64(-b))); elseif (z <= -8e-35) tmp = Float64(c * Float64(a * j)); elseif (z <= 1.05e-134) tmp = Float64(y * Float64(i * Float64(-j))); elseif (z <= 6.5e+120) tmp = Float64(t * Float64(b * i)); 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.6e+51) tmp = c * (z * -b); elseif (z <= -8e-35) tmp = c * (a * j); elseif (z <= 1.05e-134) tmp = y * (i * -j); elseif (z <= 6.5e+120) tmp = t * (b * i); else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -3.6e+51], N[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8e-35], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.05e-134], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5e+120], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.6 \cdot 10^{+51}:\\
\;\;\;\;c \cdot \left(z \cdot \left(-b\right)\right)\\
\mathbf{elif}\;z \leq -8 \cdot 10^{-35}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{elif}\;z \leq 1.05 \cdot 10^{-134}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+120}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if z < -3.60000000000000011e51Initial program 67.6%
cancel-sign-sub67.6%
cancel-sign-sub-inv67.6%
*-commutative67.6%
remove-double-neg67.6%
*-commutative67.6%
Simplified67.6%
Taylor expanded in c around inf 56.5%
*-commutative56.5%
Simplified56.5%
Taylor expanded in j around 0 52.8%
associate-*r*52.8%
neg-mul-152.8%
Simplified52.8%
if -3.60000000000000011e51 < z < -8.00000000000000006e-35Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in c around inf 44.7%
*-commutative44.7%
Simplified44.7%
Taylor expanded in j around inf 39.8%
*-commutative39.8%
Simplified39.8%
if -8.00000000000000006e-35 < z < 1.05e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in y around inf 42.4%
*-commutative42.4%
mul-1-neg42.4%
unsub-neg42.4%
Simplified42.4%
Taylor expanded in z around 0 38.1%
mul-1-neg38.1%
distribute-rgt-neg-in38.1%
*-commutative38.1%
Simplified38.1%
if 1.05e-134 < z < 6.4999999999999997e120Initial program 74.5%
cancel-sign-sub74.5%
cancel-sign-sub-inv74.5%
*-commutative74.5%
remove-double-neg74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in t around inf 60.6%
*-commutative60.6%
associate-*r*60.6%
neg-mul-160.6%
cancel-sign-sub60.6%
+-commutative60.6%
mul-1-neg60.6%
unsub-neg60.6%
Simplified60.6%
Taylor expanded in i around inf 43.9%
if 6.4999999999999997e120 < z Initial program 74.4%
cancel-sign-sub74.4%
cancel-sign-sub-inv74.4%
*-commutative74.4%
remove-double-neg74.4%
*-commutative74.4%
Simplified74.4%
Taylor expanded in y around inf 60.2%
*-commutative60.2%
mul-1-neg60.2%
unsub-neg60.2%
Simplified60.2%
Taylor expanded in z around inf 56.3%
Final simplification45.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -6.2e+50)
(* z (* b (- c)))
(if (<= z -1.4e-34)
(* c (* a j))
(if (<= z 1.55e-134)
(* y (* i (- j)))
(if (<= z 5.4e+127) (* t (* b i)) (* 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 <= -6.2e+50) {
tmp = z * (b * -c);
} else if (z <= -1.4e-34) {
tmp = c * (a * j);
} else if (z <= 1.55e-134) {
tmp = y * (i * -j);
} else if (z <= 5.4e+127) {
tmp = t * (b * i);
} 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 <= (-6.2d+50)) then
tmp = z * (b * -c)
else if (z <= (-1.4d-34)) then
tmp = c * (a * j)
else if (z <= 1.55d-134) then
tmp = y * (i * -j)
else if (z <= 5.4d+127) then
tmp = t * (b * i)
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 <= -6.2e+50) {
tmp = z * (b * -c);
} else if (z <= -1.4e-34) {
tmp = c * (a * j);
} else if (z <= 1.55e-134) {
tmp = y * (i * -j);
} else if (z <= 5.4e+127) {
tmp = t * (b * i);
} else {
tmp = y * (x * z);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -6.2e+50: tmp = z * (b * -c) elif z <= -1.4e-34: tmp = c * (a * j) elif z <= 1.55e-134: tmp = y * (i * -j) elif z <= 5.4e+127: tmp = t * (b * i) else: tmp = y * (x * z) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -6.2e+50) tmp = Float64(z * Float64(b * Float64(-c))); elseif (z <= -1.4e-34) tmp = Float64(c * Float64(a * j)); elseif (z <= 1.55e-134) tmp = Float64(y * Float64(i * Float64(-j))); elseif (z <= 5.4e+127) tmp = Float64(t * Float64(b * i)); 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 <= -6.2e+50) tmp = z * (b * -c); elseif (z <= -1.4e-34) tmp = c * (a * j); elseif (z <= 1.55e-134) tmp = y * (i * -j); elseif (z <= 5.4e+127) tmp = t * (b * i); else tmp = y * (x * z); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -6.2e+50], N[(z * N[(b * (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.4e-34], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e-134], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.4e+127], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.2 \cdot 10^{+50}:\\
\;\;\;\;z \cdot \left(b \cdot \left(-c\right)\right)\\
\mathbf{elif}\;z \leq -1.4 \cdot 10^{-34}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-134}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{+127}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\end{array}
\end{array}
if z < -6.20000000000000006e50Initial program 67.6%
cancel-sign-sub67.6%
cancel-sign-sub-inv67.6%
*-commutative67.6%
remove-double-neg67.6%
*-commutative67.6%
Simplified67.6%
Taylor expanded in z around inf 77.4%
Taylor expanded in y around 0 53.9%
neg-mul-153.9%
distribute-rgt-neg-in53.9%
Simplified53.9%
if -6.20000000000000006e50 < z < -1.39999999999999998e-34Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in c around inf 44.7%
*-commutative44.7%
Simplified44.7%
Taylor expanded in j around inf 39.8%
*-commutative39.8%
Simplified39.8%
if -1.39999999999999998e-34 < z < 1.55000000000000003e-134Initial program 81.8%
cancel-sign-sub81.8%
cancel-sign-sub-inv81.8%
*-commutative81.8%
remove-double-neg81.8%
*-commutative81.8%
Simplified81.8%
Taylor expanded in y around inf 42.4%
*-commutative42.4%
mul-1-neg42.4%
unsub-neg42.4%
Simplified42.4%
Taylor expanded in z around 0 38.1%
mul-1-neg38.1%
distribute-rgt-neg-in38.1%
*-commutative38.1%
Simplified38.1%
if 1.55000000000000003e-134 < z < 5.4000000000000004e127Initial program 74.5%
cancel-sign-sub74.5%
cancel-sign-sub-inv74.5%
*-commutative74.5%
remove-double-neg74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in t around inf 60.6%
*-commutative60.6%
associate-*r*60.6%
neg-mul-160.6%
cancel-sign-sub60.6%
+-commutative60.6%
mul-1-neg60.6%
unsub-neg60.6%
Simplified60.6%
Taylor expanded in i around inf 43.9%
if 5.4000000000000004e127 < z Initial program 74.4%
cancel-sign-sub74.4%
cancel-sign-sub-inv74.4%
*-commutative74.4%
remove-double-neg74.4%
*-commutative74.4%
Simplified74.4%
Taylor expanded in y around inf 60.2%
*-commutative60.2%
mul-1-neg60.2%
unsub-neg60.2%
Simplified60.2%
Taylor expanded in z around inf 56.3%
Final simplification45.6%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= b -6.5e-98) (not (<= b 1.45e-32))) (* i (* t b)) (* c (* a 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 <= -6.5e-98) || !(b <= 1.45e-32)) {
tmp = i * (t * b);
} else {
tmp = c * (a * 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 <= (-6.5d-98)) .or. (.not. (b <= 1.45d-32))) then
tmp = i * (t * b)
else
tmp = c * (a * 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 <= -6.5e-98) || !(b <= 1.45e-32)) {
tmp = i * (t * b);
} else {
tmp = c * (a * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (b <= -6.5e-98) or not (b <= 1.45e-32): tmp = i * (t * b) else: tmp = c * (a * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((b <= -6.5e-98) || !(b <= 1.45e-32)) tmp = Float64(i * Float64(t * b)); else tmp = Float64(c * Float64(a * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((b <= -6.5e-98) || ~((b <= 1.45e-32))) tmp = i * (t * b); else tmp = c * (a * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -6.5e-98], N[Not[LessEqual[b, 1.45e-32]], $MachinePrecision]], N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.5 \cdot 10^{-98} \lor \neg \left(b \leq 1.45 \cdot 10^{-32}\right):\\
\;\;\;\;i \cdot \left(t \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\end{array}
\end{array}
if b < -6.50000000000000017e-98 or 1.44999999999999998e-32 < b Initial program 78.9%
cancel-sign-sub78.9%
cancel-sign-sub-inv78.9%
*-commutative78.9%
remove-double-neg78.9%
*-commutative78.9%
Simplified78.9%
Taylor expanded in j around 0 74.2%
Taylor expanded in i around inf 35.8%
if -6.50000000000000017e-98 < b < 1.44999999999999998e-32Initial program 70.6%
cancel-sign-sub70.6%
cancel-sign-sub-inv70.6%
*-commutative70.6%
remove-double-neg70.6%
*-commutative70.6%
Simplified70.6%
Taylor expanded in c around inf 34.4%
*-commutative34.4%
Simplified34.4%
Taylor expanded in j around inf 29.6%
*-commutative29.6%
Simplified29.6%
Final simplification33.3%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -8.2e-98) (* i (* t b)) (if (<= b 1.8e-32) (* c (* a j)) (* t (* 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 <= -8.2e-98) {
tmp = i * (t * b);
} else if (b <= 1.8e-32) {
tmp = c * (a * j);
} else {
tmp = t * (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 <= (-8.2d-98)) then
tmp = i * (t * b)
else if (b <= 1.8d-32) then
tmp = c * (a * j)
else
tmp = t * (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 <= -8.2e-98) {
tmp = i * (t * b);
} else if (b <= 1.8e-32) {
tmp = c * (a * j);
} else {
tmp = t * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -8.2e-98: tmp = i * (t * b) elif b <= 1.8e-32: tmp = c * (a * j) else: tmp = t * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -8.2e-98) tmp = Float64(i * Float64(t * b)); elseif (b <= 1.8e-32) tmp = Float64(c * Float64(a * j)); else tmp = Float64(t * 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 <= -8.2e-98) tmp = i * (t * b); elseif (b <= 1.8e-32) tmp = c * (a * j); else tmp = t * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.2e-98], N[(i * N[(t * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.8e-32], N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision], N[(t * N[(b * i), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.2 \cdot 10^{-98}:\\
\;\;\;\;i \cdot \left(t \cdot b\right)\\
\mathbf{elif}\;b \leq 1.8 \cdot 10^{-32}:\\
\;\;\;\;c \cdot \left(a \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if b < -8.1999999999999996e-98Initial program 77.8%
cancel-sign-sub77.8%
cancel-sign-sub-inv77.8%
*-commutative77.8%
remove-double-neg77.8%
*-commutative77.8%
Simplified77.8%
Taylor expanded in j around 0 78.0%
Taylor expanded in i around inf 32.2%
if -8.1999999999999996e-98 < b < 1.79999999999999996e-32Initial program 70.6%
cancel-sign-sub70.6%
cancel-sign-sub-inv70.6%
*-commutative70.6%
remove-double-neg70.6%
*-commutative70.6%
Simplified70.6%
Taylor expanded in c around inf 34.4%
*-commutative34.4%
Simplified34.4%
Taylor expanded in j around inf 29.6%
*-commutative29.6%
Simplified29.6%
if 1.79999999999999996e-32 < b Initial program 80.0%
cancel-sign-sub80.0%
cancel-sign-sub-inv80.0%
*-commutative80.0%
remove-double-neg80.0%
*-commutative80.0%
Simplified80.0%
Taylor expanded in t around inf 47.8%
*-commutative47.8%
associate-*r*47.8%
neg-mul-147.8%
cancel-sign-sub47.8%
+-commutative47.8%
mul-1-neg47.8%
unsub-neg47.8%
Simplified47.8%
Taylor expanded in i around inf 39.1%
Final simplification33.3%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* c j)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (c * j);
}
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 * (c * j)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (c * j);
}
def code(x, y, z, t, a, b, c, i, j): return a * (c * j)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(c * j)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (c * j); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(c * j), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(c \cdot j\right)
\end{array}
Initial program 75.6%
cancel-sign-sub75.6%
cancel-sign-sub-inv75.6%
*-commutative75.6%
remove-double-neg75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in c around inf 40.6%
*-commutative40.6%
Simplified40.6%
Taylor expanded in j around inf 21.3%
*-commutative21.3%
Simplified21.3%
Taylor expanded in c around 0 21.3%
*-commutative21.3%
associate-*r*19.1%
*-commutative19.1%
Simplified19.1%
Final simplification19.1%
(FPCore (x y z t a b c i j) :precision binary64 (* c (* a j)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return c * (a * j);
}
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 = c * (a * j)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return c * (a * j);
}
def code(x, y, z, t, a, b, c, i, j): return c * (a * j)
function code(x, y, z, t, a, b, c, i, j) return Float64(c * Float64(a * j)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = c * (a * j); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(c * N[(a * j), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
c \cdot \left(a \cdot j\right)
\end{array}
Initial program 75.6%
cancel-sign-sub75.6%
cancel-sign-sub-inv75.6%
*-commutative75.6%
remove-double-neg75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in c around inf 40.6%
*-commutative40.6%
Simplified40.6%
Taylor expanded in j around inf 21.3%
*-commutative21.3%
Simplified21.3%
Final simplification21.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* c a) (* y i))))
(t_2
(+
(-
(* x (- (* y z) (* t a)))
(/
(* b (- (pow (* c z) 2.0) (pow (* t i) 2.0)))
(+ (* c z) (* t i))))
t_1)))
(if (< x -1.469694296777705e-64)
t_2
(if (< x 3.2113527362226803e-147)
(- (* (- (* b i) (* x a)) t) (- (* z (* c b)) 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 * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (pow((c * z), 2.0) - pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 * ((c * a) - (y * i))
t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ** 2.0d0) - ((t * i) ** 2.0d0))) / ((c * z) + (t * i)))) + t_1
if (x < (-1.469694296777705d-64)) then
tmp = t_2
else if (x < 3.2113527362226803d-147) then
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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 * ((c * a) - (y * i));
double t_2 = ((x * ((y * z) - (t * a))) - ((b * (Math.pow((c * z), 2.0) - Math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1;
double tmp;
if (x < -1.469694296777705e-64) {
tmp = t_2;
} else if (x < 3.2113527362226803e-147) {
tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - t_1);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((c * a) - (y * i)) t_2 = ((x * ((y * z) - (t * a))) - ((b * (math.pow((c * z), 2.0) - math.pow((t * i), 2.0))) / ((c * z) + (t * i)))) + t_1 tmp = 0 if x < -1.469694296777705e-64: tmp = t_2 elif x < 3.2113527362226803e-147: tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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(c * a) - Float64(y * i))) t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(Float64(b * Float64((Float64(c * z) ^ 2.0) - (Float64(t * i) ^ 2.0))) / Float64(Float64(c * z) + Float64(t * i)))) + t_1) tmp = 0.0 if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = Float64(Float64(Float64(Float64(b * i) - Float64(x * a)) * t) - Float64(Float64(z * Float64(c * b)) - 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 * ((c * a) - (y * i)); t_2 = ((x * ((y * z) - (t * a))) - ((b * (((c * z) ^ 2.0) - ((t * i) ^ 2.0))) / ((c * z) + (t * i)))) + t_1; tmp = 0.0; if (x < -1.469694296777705e-64) tmp = t_2; elseif (x < 3.2113527362226803e-147) tmp = (((b * i) - (x * a)) * t) - ((z * (c * b)) - 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[(c * a), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[Power[N[(c * z), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(t * i), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * z), $MachinePrecision] + N[(t * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[Less[x, -1.469694296777705e-64], t$95$2, If[Less[x, 3.2113527362226803e-147], N[(N[(N[(N[(b * i), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision] - N[(N[(z * N[(c * b), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(c \cdot a - y \cdot i\right)\\
t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - \frac{b \cdot \left({\left(c \cdot z\right)}^{2} - {\left(t \cdot i\right)}^{2}\right)}{c \cdot z + t \cdot i}\right) + t_1\\
\mathbf{if}\;x < -1.469694296777705 \cdot 10^{-64}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;x < 3.2113527362226803 \cdot 10^{-147}:\\
\;\;\;\;\left(b \cdot i - x \cdot a\right) \cdot t - \left(z \cdot \left(c \cdot b\right) - t_1\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2023195
(FPCore (x y z t a b c i j)
:name "Data.Colour.Matrix:determinant from colour-2.3.3, A"
:precision binary64
:herbie-target
(if (< x -1.469694296777705e-64) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2.0) (pow (* t i) 2.0))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i)))) (if (< x 3.2113527362226803e-147) (- (* (- (* b i) (* x a)) t) (- (* z (* c b)) (* j (- (* c a) (* y i))))) (+ (- (* x (- (* y z) (* t a))) (/ (* b (- (pow (* c z) 2.0) (pow (* t i) 2.0))) (+ (* c z) (* t i)))) (* j (- (* c a) (* y i))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* t i)))) (* j (- (* c a) (* y i)))))