
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 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) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c))))
(t_2 (- (* y z) (* t a)))
(t_3 (- (* t c) (* y i))))
(if (<= (+ (+ (* x t_2) t_1) (* j t_3)) INFINITY)
(fma x t_2 (fma j t_3 t_1))
(* y (- (* x z) (* i j))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = (y * z) - (t * a);
double t_3 = (t * c) - (y * i);
double tmp;
if ((((x * t_2) + t_1) + (j * t_3)) <= ((double) INFINITY)) {
tmp = fma(x, t_2, fma(j, t_3, t_1));
} else {
tmp = y * ((x * z) - (i * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(Float64(y * z) - Float64(t * a)) t_3 = Float64(Float64(t * c) - Float64(y * i)) tmp = 0.0 if (Float64(Float64(Float64(x * t_2) + t_1) + Float64(j * t_3)) <= Inf) tmp = fma(x, t_2, fma(j, t_3, t_1)); else tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x * t$95$2), $MachinePrecision] + t$95$1), $MachinePrecision] + N[(j * t$95$3), $MachinePrecision]), $MachinePrecision], Infinity], N[(x * t$95$2 + N[(j * t$95$3 + t$95$1), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := y \cdot z - t \cdot a\\
t_3 := t \cdot c - y \cdot i\\
\mathbf{if}\;\left(x \cdot t_2 + t_1\right) + j \cdot t_3 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(x, t_2, \mathsf{fma}\left(j, t_3, t_1\right)\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 90.7%
sub-neg90.7%
associate-+l+90.7%
fma-def90.7%
+-commutative90.7%
fma-def90.7%
*-commutative90.7%
*-commutative90.7%
distribute-rgt-neg-in90.7%
sub-neg90.7%
+-commutative90.7%
distribute-neg-in90.7%
unsub-neg90.7%
remove-double-neg90.7%
*-commutative90.7%
*-commutative90.7%
Simplified90.7%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
*-commutative0.0%
Simplified0.0%
Taylor expanded in y around inf 57.0%
+-commutative57.0%
mul-1-neg57.0%
unsub-neg57.0%
Simplified57.0%
Final simplification84.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* y (- (* x z) (* i j))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = y * ((x * z) - (i * j));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = y * ((x * z) - (i * j));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = y * ((x * z) - (i * j)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = y * ((x * z) - (i * j)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 90.7%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
cancel-sign-sub0.0%
cancel-sign-sub-inv0.0%
*-commutative0.0%
*-commutative0.0%
remove-double-neg0.0%
*-commutative0.0%
*-commutative0.0%
Simplified0.0%
Taylor expanded in y around inf 57.0%
+-commutative57.0%
mul-1-neg57.0%
unsub-neg57.0%
Simplified57.0%
Final simplification84.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -2e+101)
(+ (* j (* t c)) t_1)
(if (<= x 3.4e+19)
(+
(* j (- (* t c) (* y i)))
(- (* z (* x y)) (* b (- (* z c) (* a i)))))
(+ t_1 (* b (- (* a i) (* z c))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -2e+101) {
tmp = (j * (t * c)) + t_1;
} else if (x <= 3.4e+19) {
tmp = (j * ((t * c) - (y * i))) + ((z * (x * y)) - (b * ((z * c) - (a * i))));
} else {
tmp = t_1 + (b * ((a * i) - (z * c)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if (x <= (-2d+101)) then
tmp = (j * (t * c)) + t_1
else if (x <= 3.4d+19) then
tmp = (j * ((t * c) - (y * i))) + ((z * (x * y)) - (b * ((z * c) - (a * i))))
else
tmp = t_1 + (b * ((a * i) - (z * c)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -2e+101) {
tmp = (j * (t * c)) + t_1;
} else if (x <= 3.4e+19) {
tmp = (j * ((t * c) - (y * i))) + ((z * (x * y)) - (b * ((z * c) - (a * i))));
} else {
tmp = t_1 + (b * ((a * i) - (z * c)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if x <= -2e+101: tmp = (j * (t * c)) + t_1 elif x <= 3.4e+19: tmp = (j * ((t * c) - (y * i))) + ((z * (x * y)) - (b * ((z * c) - (a * i)))) else: tmp = t_1 + (b * ((a * i) - (z * c))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -2e+101) tmp = Float64(Float64(j * Float64(t * c)) + t_1); elseif (x <= 3.4e+19) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(Float64(z * Float64(x * y)) - Float64(b * Float64(Float64(z * c) - Float64(a * i))))); else tmp = Float64(t_1 + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -2e+101) tmp = (j * (t * c)) + t_1; elseif (x <= 3.4e+19) tmp = (j * ((t * c) - (y * i))) + ((z * (x * y)) - (b * ((z * c) - (a * i)))); else tmp = t_1 + (b * ((a * i) - (z * c))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2e+101], N[(N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[x, 3.4e+19], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -2 \cdot 10^{+101}:\\
\;\;\;\;j \cdot \left(t \cdot c\right) + t_1\\
\mathbf{elif}\;x \leq 3.4 \cdot 10^{+19}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + \left(z \cdot \left(x \cdot y\right) - b \cdot \left(z \cdot c - a \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t_1 + b \cdot \left(a \cdot i - z \cdot c\right)\\
\end{array}
\end{array}
if x < -2e101Initial program 73.1%
cancel-sign-sub73.1%
cancel-sign-sub-inv73.1%
*-commutative73.1%
*-commutative73.1%
remove-double-neg73.1%
*-commutative73.1%
*-commutative73.1%
Simplified73.1%
Taylor expanded in b around 0 75.5%
Taylor expanded in c around inf 75.5%
associate-*r*77.9%
Simplified77.9%
if -2e101 < x < 3.4e19Initial program 78.8%
cancel-sign-sub78.8%
cancel-sign-sub-inv78.8%
*-commutative78.8%
*-commutative78.8%
remove-double-neg78.8%
*-commutative78.8%
*-commutative78.8%
Simplified78.8%
Taylor expanded in y around inf 79.5%
*-commutative79.5%
associate-*l*78.9%
*-commutative78.9%
Simplified78.9%
if 3.4e19 < x Initial program 65.3%
+-commutative65.3%
fma-def66.8%
*-commutative66.8%
*-commutative66.8%
*-commutative66.8%
*-commutative66.8%
Simplified66.8%
Taylor expanded in j around 0 75.4%
Final simplification77.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))) (t_2 (* j (- (* t c) (* y i)))))
(if (<= j -3.15e+140)
(+ t_2 (* b (* a i)))
(if (or (<= j 1.1e-198) (and (not (<= j 3e-96)) (<= j 4.6e+28)))
(+ t_1 (* b (- (* a i) (* z c))))
(+ t_1 t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -3.15e+140) {
tmp = t_2 + (b * (a * i));
} else if ((j <= 1.1e-198) || (!(j <= 3e-96) && (j <= 4.6e+28))) {
tmp = t_1 + (b * ((a * i) - (z * c)));
} else {
tmp = t_1 + t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
t_2 = j * ((t * c) - (y * i))
if (j <= (-3.15d+140)) then
tmp = t_2 + (b * (a * i))
else if ((j <= 1.1d-198) .or. (.not. (j <= 3d-96)) .and. (j <= 4.6d+28)) then
tmp = t_1 + (b * ((a * i) - (z * c)))
else
tmp = t_1 + t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -3.15e+140) {
tmp = t_2 + (b * (a * i));
} else if ((j <= 1.1e-198) || (!(j <= 3e-96) && (j <= 4.6e+28))) {
tmp = t_1 + (b * ((a * i) - (z * c)));
} else {
tmp = t_1 + t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) t_2 = j * ((t * c) - (y * i)) tmp = 0 if j <= -3.15e+140: tmp = t_2 + (b * (a * i)) elif (j <= 1.1e-198) or (not (j <= 3e-96) and (j <= 4.6e+28)): tmp = t_1 + (b * ((a * i) - (z * c))) else: tmp = t_1 + t_2 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(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -3.15e+140) tmp = Float64(t_2 + Float64(b * Float64(a * i))); elseif ((j <= 1.1e-198) || (!(j <= 3e-96) && (j <= 4.6e+28))) tmp = Float64(t_1 + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(t_1 + t_2); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -3.15e+140) tmp = t_2 + (b * (a * i)); elseif ((j <= 1.1e-198) || (~((j <= 3e-96)) && (j <= 4.6e+28))) tmp = t_1 + (b * ((a * i) - (z * c))); else tmp = t_1 + t_2; 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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -3.15e+140], N[(t$95$2 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[j, 1.1e-198], And[N[Not[LessEqual[j, 3e-96]], $MachinePrecision], LessEqual[j, 4.6e+28]]], N[(t$95$1 + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -3.15 \cdot 10^{+140}:\\
\;\;\;\;t_2 + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;j \leq 1.1 \cdot 10^{-198} \lor \neg \left(j \leq 3 \cdot 10^{-96}\right) \land j \leq 4.6 \cdot 10^{+28}:\\
\;\;\;\;t_1 + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t_1 + t_2\\
\end{array}
\end{array}
if j < -3.14999999999999986e140Initial program 71.4%
cancel-sign-sub71.4%
cancel-sign-sub-inv71.4%
*-commutative71.4%
*-commutative71.4%
remove-double-neg71.4%
*-commutative71.4%
*-commutative71.4%
Simplified71.4%
Taylor expanded in i around inf 80.0%
associate-*r*82.8%
*-commutative82.8%
Simplified82.8%
if -3.14999999999999986e140 < j < 1.1e-198 or 3e-96 < j < 4.59999999999999968e28Initial program 73.3%
+-commutative73.3%
fma-def73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in j around 0 78.5%
if 1.1e-198 < j < 3e-96 or 4.59999999999999968e28 < j Initial program 77.7%
cancel-sign-sub77.7%
cancel-sign-sub-inv77.7%
*-commutative77.7%
*-commutative77.7%
remove-double-neg77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Taylor expanded in b around 0 72.7%
Final simplification77.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a))))
(t_2 (- (* z (* x y)) (* b (- (* z c) (* a i)))))
(t_3 (* j (- (* t c) (* y i)))))
(if (<= j -4.3e+57)
(+ t_3 (* b (* a i)))
(if (<= j -5.5e-105)
t_2
(if (<= j -4.6e-223)
t_1
(if (<= j 5.6e-198)
t_2
(if (<= j 9e+19)
(+ (* j (* t c)) t_1)
(if (<= j 1.6e+141) (* y (- (* x z) (* i j))) 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 = x * ((y * z) - (t * a));
double t_2 = (z * (x * y)) - (b * ((z * c) - (a * i)));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -4.3e+57) {
tmp = t_3 + (b * (a * i));
} else if (j <= -5.5e-105) {
tmp = t_2;
} else if (j <= -4.6e-223) {
tmp = t_1;
} else if (j <= 5.6e-198) {
tmp = t_2;
} else if (j <= 9e+19) {
tmp = (j * (t * c)) + t_1;
} else if (j <= 1.6e+141) {
tmp = y * ((x * z) - (i * j));
} 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 = x * ((y * z) - (t * a))
t_2 = (z * (x * y)) - (b * ((z * c) - (a * i)))
t_3 = j * ((t * c) - (y * i))
if (j <= (-4.3d+57)) then
tmp = t_3 + (b * (a * i))
else if (j <= (-5.5d-105)) then
tmp = t_2
else if (j <= (-4.6d-223)) then
tmp = t_1
else if (j <= 5.6d-198) then
tmp = t_2
else if (j <= 9d+19) then
tmp = (j * (t * c)) + t_1
else if (j <= 1.6d+141) then
tmp = y * ((x * z) - (i * j))
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 = x * ((y * z) - (t * a));
double t_2 = (z * (x * y)) - (b * ((z * c) - (a * i)));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -4.3e+57) {
tmp = t_3 + (b * (a * i));
} else if (j <= -5.5e-105) {
tmp = t_2;
} else if (j <= -4.6e-223) {
tmp = t_1;
} else if (j <= 5.6e-198) {
tmp = t_2;
} else if (j <= 9e+19) {
tmp = (j * (t * c)) + t_1;
} else if (j <= 1.6e+141) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) t_2 = (z * (x * y)) - (b * ((z * c) - (a * i))) t_3 = j * ((t * c) - (y * i)) tmp = 0 if j <= -4.3e+57: tmp = t_3 + (b * (a * i)) elif j <= -5.5e-105: tmp = t_2 elif j <= -4.6e-223: tmp = t_1 elif j <= 5.6e-198: tmp = t_2 elif j <= 9e+19: tmp = (j * (t * c)) + t_1 elif j <= 1.6e+141: tmp = y * ((x * z) - (i * j)) else: tmp = t_3 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(z * Float64(x * y)) - Float64(b * Float64(Float64(z * c) - Float64(a * i)))) t_3 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -4.3e+57) tmp = Float64(t_3 + Float64(b * Float64(a * i))); elseif (j <= -5.5e-105) tmp = t_2; elseif (j <= -4.6e-223) tmp = t_1; elseif (j <= 5.6e-198) tmp = t_2; elseif (j <= 9e+19) tmp = Float64(Float64(j * Float64(t * c)) + t_1); elseif (j <= 1.6e+141) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); else tmp = t_3; 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 = (z * (x * y)) - (b * ((z * c) - (a * i))); t_3 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -4.3e+57) tmp = t_3 + (b * (a * i)); elseif (j <= -5.5e-105) tmp = t_2; elseif (j <= -4.6e-223) tmp = t_1; elseif (j <= 5.6e-198) tmp = t_2; elseif (j <= 9e+19) tmp = (j * (t * c)) + t_1; elseif (j <= 1.6e+141) tmp = y * ((x * z) - (i * j)); else tmp = t_3; 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[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -4.3e+57], N[(t$95$3 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -5.5e-105], t$95$2, If[LessEqual[j, -4.6e-223], t$95$1, If[LessEqual[j, 5.6e-198], t$95$2, If[LessEqual[j, 9e+19], N[(N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[j, 1.6e+141], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := z \cdot \left(x \cdot y\right) - b \cdot \left(z \cdot c - a \cdot i\right)\\
t_3 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -4.3 \cdot 10^{+57}:\\
\;\;\;\;t_3 + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;j \leq -5.5 \cdot 10^{-105}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;j \leq -4.6 \cdot 10^{-223}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;j \leq 5.6 \cdot 10^{-198}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;j \leq 9 \cdot 10^{+19}:\\
\;\;\;\;j \cdot \left(t \cdot c\right) + t_1\\
\mathbf{elif}\;j \leq 1.6 \cdot 10^{+141}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if j < -4.30000000000000033e57Initial program 74.1%
cancel-sign-sub74.1%
cancel-sign-sub-inv74.1%
*-commutative74.1%
*-commutative74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in i around inf 72.5%
associate-*r*74.5%
*-commutative74.5%
Simplified74.5%
if -4.30000000000000033e57 < j < -5.50000000000000029e-105 or -4.5999999999999999e-223 < j < 5.5999999999999998e-198Initial program 74.9%
+-commutative74.9%
fma-def74.9%
*-commutative74.9%
*-commutative74.9%
*-commutative74.9%
*-commutative74.9%
Simplified74.9%
Taylor expanded in j around 0 78.9%
Taylor expanded in y around inf 68.6%
*-commutative68.6%
associate-*l*66.4%
Simplified66.4%
if -5.50000000000000029e-105 < j < -4.5999999999999999e-223Initial program 64.7%
+-commutative64.7%
fma-def64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
*-commutative64.7%
Simplified64.7%
Taylor expanded in j around 0 75.6%
Taylor expanded in x around inf 79.2%
if 5.5999999999999998e-198 < j < 9e19Initial program 73.9%
cancel-sign-sub73.9%
cancel-sign-sub-inv73.9%
*-commutative73.9%
*-commutative73.9%
remove-double-neg73.9%
*-commutative73.9%
*-commutative73.9%
Simplified73.9%
Taylor expanded in b around 0 70.9%
Taylor expanded in c around inf 70.9%
associate-*r*64.4%
Simplified64.4%
if 9e19 < j < 1.60000000000000009e141Initial program 70.4%
cancel-sign-sub70.4%
cancel-sign-sub-inv70.4%
*-commutative70.4%
*-commutative70.4%
remove-double-neg70.4%
*-commutative70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in y around inf 71.3%
+-commutative71.3%
mul-1-neg71.3%
unsub-neg71.3%
Simplified71.3%
if 1.60000000000000009e141 < j Initial program 84.0%
cancel-sign-sub84.0%
cancel-sign-sub-inv84.0%
*-commutative84.0%
*-commutative84.0%
remove-double-neg84.0%
*-commutative84.0%
*-commutative84.0%
Simplified84.0%
Taylor expanded in b around 0 73.1%
Taylor expanded in j around inf 72.2%
Final simplification70.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))) (t_2 (* j (- (* t c) (* y i)))))
(if (<= j -0.018)
(+ t_2 (* b (* a i)))
(if (<= j -3.1e-245)
t_1
(if (<= j 6.5e-204)
(* b (- (* a i) (* z c)))
(if (<= j 3.4e+18)
(+ (* j (* t c)) t_1)
(if (<= j 3.4e+140) (* y (- (* x z) (* i j))) t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -0.018) {
tmp = t_2 + (b * (a * i));
} else if (j <= -3.1e-245) {
tmp = t_1;
} else if (j <= 6.5e-204) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 3.4e+18) {
tmp = (j * (t * c)) + t_1;
} else if (j <= 3.4e+140) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
t_2 = j * ((t * c) - (y * i))
if (j <= (-0.018d0)) then
tmp = t_2 + (b * (a * i))
else if (j <= (-3.1d-245)) then
tmp = t_1
else if (j <= 6.5d-204) then
tmp = b * ((a * i) - (z * c))
else if (j <= 3.4d+18) then
tmp = (j * (t * c)) + t_1
else if (j <= 3.4d+140) then
tmp = y * ((x * z) - (i * j))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -0.018) {
tmp = t_2 + (b * (a * i));
} else if (j <= -3.1e-245) {
tmp = t_1;
} else if (j <= 6.5e-204) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 3.4e+18) {
tmp = (j * (t * c)) + t_1;
} else if (j <= 3.4e+140) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) t_2 = j * ((t * c) - (y * i)) tmp = 0 if j <= -0.018: tmp = t_2 + (b * (a * i)) elif j <= -3.1e-245: tmp = t_1 elif j <= 6.5e-204: tmp = b * ((a * i) - (z * c)) elif j <= 3.4e+18: tmp = (j * (t * c)) + t_1 elif j <= 3.4e+140: tmp = y * ((x * z) - (i * j)) else: tmp = t_2 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(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -0.018) tmp = Float64(t_2 + Float64(b * Float64(a * i))); elseif (j <= -3.1e-245) tmp = t_1; elseif (j <= 6.5e-204) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (j <= 3.4e+18) tmp = Float64(Float64(j * Float64(t * c)) + t_1); elseif (j <= 3.4e+140) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -0.018) tmp = t_2 + (b * (a * i)); elseif (j <= -3.1e-245) tmp = t_1; elseif (j <= 6.5e-204) tmp = b * ((a * i) - (z * c)); elseif (j <= 3.4e+18) tmp = (j * (t * c)) + t_1; elseif (j <= 3.4e+140) tmp = y * ((x * z) - (i * j)); else tmp = t_2; 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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -0.018], N[(t$95$2 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -3.1e-245], t$95$1, If[LessEqual[j, 6.5e-204], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 3.4e+18], N[(N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[j, 3.4e+140], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -0.018:\\
\;\;\;\;t_2 + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;j \leq -3.1 \cdot 10^{-245}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;j \leq 6.5 \cdot 10^{-204}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 3.4 \cdot 10^{+18}:\\
\;\;\;\;j \cdot \left(t \cdot c\right) + t_1\\
\mathbf{elif}\;j \leq 3.4 \cdot 10^{+140}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if j < -0.0179999999999999986Initial program 75.4%
cancel-sign-sub75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
*-commutative75.4%
remove-double-neg75.4%
*-commutative75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in i around inf 72.6%
associate-*r*74.3%
*-commutative74.3%
Simplified74.3%
if -0.0179999999999999986 < j < -3.10000000000000003e-245Initial program 69.7%
+-commutative69.7%
fma-def69.7%
*-commutative69.7%
*-commutative69.7%
*-commutative69.7%
*-commutative69.7%
Simplified69.7%
Taylor expanded in j around 0 76.6%
Taylor expanded in x around inf 65.1%
if -3.10000000000000003e-245 < j < 6.49999999999999939e-204Initial program 75.4%
cancel-sign-sub75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
*-commutative75.4%
remove-double-neg75.4%
*-commutative75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in b around inf 55.7%
if 6.49999999999999939e-204 < j < 3.4e18Initial program 71.7%
cancel-sign-sub71.7%
cancel-sign-sub-inv71.7%
*-commutative71.7%
*-commutative71.7%
remove-double-neg71.7%
*-commutative71.7%
*-commutative71.7%
Simplified71.7%
Taylor expanded in b around 0 68.8%
Taylor expanded in c around inf 68.8%
associate-*r*62.5%
Simplified62.5%
if 3.4e18 < j < 3.4e140Initial program 70.4%
cancel-sign-sub70.4%
cancel-sign-sub-inv70.4%
*-commutative70.4%
*-commutative70.4%
remove-double-neg70.4%
*-commutative70.4%
*-commutative70.4%
Simplified70.4%
Taylor expanded in y around inf 71.3%
+-commutative71.3%
mul-1-neg71.3%
unsub-neg71.3%
Simplified71.3%
if 3.4e140 < j Initial program 84.0%
cancel-sign-sub84.0%
cancel-sign-sub-inv84.0%
*-commutative84.0%
*-commutative84.0%
remove-double-neg84.0%
*-commutative84.0%
*-commutative84.0%
Simplified84.0%
Taylor expanded in b around 0 73.1%
Taylor expanded in j around inf 72.2%
Final simplification67.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* b (- (* a i) (* z c))) (* x (* t a))))
(t_2 (* y (- (* x z) (* i j)))))
(if (<= y -1.1e+85)
t_2
(if (<= y 4.6e-14)
t_1
(if (<= y 3.3e+65)
(+ (* j (- (* t c) (* y i))) (* b (* a i)))
(if (<= y 3.8e+80) 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 * ((a * i) - (z * c))) - (x * (t * a));
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.1e+85) {
tmp = t_2;
} else if (y <= 4.6e-14) {
tmp = t_1;
} else if (y <= 3.3e+65) {
tmp = (j * ((t * c) - (y * i))) + (b * (a * i));
} else if (y <= 3.8e+80) {
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 * ((a * i) - (z * c))) - (x * (t * a))
t_2 = y * ((x * z) - (i * j))
if (y <= (-1.1d+85)) then
tmp = t_2
else if (y <= 4.6d-14) then
tmp = t_1
else if (y <= 3.3d+65) then
tmp = (j * ((t * c) - (y * i))) + (b * (a * i))
else if (y <= 3.8d+80) 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 * ((a * i) - (z * c))) - (x * (t * a));
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.1e+85) {
tmp = t_2;
} else if (y <= 4.6e-14) {
tmp = t_1;
} else if (y <= 3.3e+65) {
tmp = (j * ((t * c) - (y * i))) + (b * (a * i));
} else if (y <= 3.8e+80) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (b * ((a * i) - (z * c))) - (x * (t * a)) t_2 = y * ((x * z) - (i * j)) tmp = 0 if y <= -1.1e+85: tmp = t_2 elif y <= 4.6e-14: tmp = t_1 elif y <= 3.3e+65: tmp = (j * ((t * c) - (y * i))) + (b * (a * i)) elif y <= 3.8e+80: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) - Float64(x * Float64(t * a))) t_2 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -1.1e+85) tmp = t_2; elseif (y <= 4.6e-14) tmp = t_1; elseif (y <= 3.3e+65) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(b * Float64(a * i))); elseif (y <= 3.8e+80) 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 * ((a * i) - (z * c))) - (x * (t * a)); t_2 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -1.1e+85) tmp = t_2; elseif (y <= 4.6e-14) tmp = t_1; elseif (y <= 3.3e+65) tmp = (j * ((t * c) - (y * i))) + (b * (a * i)); elseif (y <= 3.8e+80) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.1e+85], t$95$2, If[LessEqual[y, 4.6e-14], t$95$1, If[LessEqual[y, 3.3e+65], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.8e+80], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right) - x \cdot \left(t \cdot a\right)\\
t_2 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -1.1 \cdot 10^{+85}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{-14}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+65}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;y \leq 3.8 \cdot 10^{+80}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if y < -1.1000000000000001e85 or 3.79999999999999997e80 < y Initial program 55.4%
cancel-sign-sub55.4%
cancel-sign-sub-inv55.4%
*-commutative55.4%
*-commutative55.4%
remove-double-neg55.4%
*-commutative55.4%
*-commutative55.4%
Simplified55.4%
Taylor expanded in y around inf 76.4%
+-commutative76.4%
mul-1-neg76.4%
unsub-neg76.4%
Simplified76.4%
if -1.1000000000000001e85 < y < 4.59999999999999996e-14 or 3.30000000000000023e65 < y < 3.79999999999999997e80Initial program 85.8%
+-commutative85.8%
fma-def85.8%
*-commutative85.8%
*-commutative85.8%
*-commutative85.8%
*-commutative85.8%
Simplified85.8%
Taylor expanded in j around 0 72.8%
Taylor expanded in y around 0 66.7%
neg-mul-166.7%
distribute-rgt-neg-in66.7%
Simplified66.7%
if 4.59999999999999996e-14 < y < 3.30000000000000023e65Initial program 76.5%
cancel-sign-sub76.5%
cancel-sign-sub-inv76.5%
*-commutative76.5%
*-commutative76.5%
remove-double-neg76.5%
*-commutative76.5%
*-commutative76.5%
Simplified76.5%
Taylor expanded in i around inf 71.4%
associate-*r*71.6%
*-commutative71.6%
Simplified71.6%
Final simplification70.5%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= b -3.85e+143) (not (<= b 95.0))) (- (* z (* x y)) (* b (- (* z c) (* a i)))) (+ (* x (- (* y z) (* t a))) (* j (- (* t c) (* y i))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -3.85e+143) || !(b <= 95.0)) {
tmp = (z * (x * y)) - (b * ((z * c) - (a * i)));
} else {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((b <= (-3.85d+143)) .or. (.not. (b <= 95.0d0))) then
tmp = (z * (x * y)) - (b * ((z * c) - (a * i)))
else
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -3.85e+143) || !(b <= 95.0)) {
tmp = (z * (x * y)) - (b * ((z * c) - (a * i)));
} else {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (b <= -3.85e+143) or not (b <= 95.0): tmp = (z * (x * y)) - (b * ((z * c) - (a * i))) else: tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((b <= -3.85e+143) || !(b <= 95.0)) tmp = Float64(Float64(z * Float64(x * y)) - Float64(b * Float64(Float64(z * c) - Float64(a * i)))); else tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((b <= -3.85e+143) || ~((b <= 95.0))) tmp = (z * (x * y)) - (b * ((z * c) - (a * i))); else tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -3.85e+143], N[Not[LessEqual[b, 95.0]], $MachinePrecision]], N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.85 \cdot 10^{+143} \lor \neg \left(b \leq 95\right):\\
\;\;\;\;z \cdot \left(x \cdot y\right) - b \cdot \left(z \cdot c - a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\end{array}
\end{array}
if b < -3.85000000000000013e143 or 95 < b Initial program 78.4%
+-commutative78.4%
fma-def78.4%
*-commutative78.4%
*-commutative78.4%
*-commutative78.4%
*-commutative78.4%
Simplified78.4%
Taylor expanded in j around 0 80.0%
Taylor expanded in y around inf 79.3%
*-commutative79.3%
associate-*l*76.2%
Simplified76.2%
if -3.85000000000000013e143 < b < 95Initial program 72.3%
cancel-sign-sub72.3%
cancel-sign-sub-inv72.3%
*-commutative72.3%
*-commutative72.3%
remove-double-neg72.3%
*-commutative72.3%
*-commutative72.3%
Simplified72.3%
Taylor expanded in b around 0 67.9%
Final simplification70.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))))
(if (<= i -4e+46)
(* j (* y (- i)))
(if (<= i -1.6e-122)
(* z (* x y))
(if (<= i 1.2e-264)
t_1
(if (<= i 7.8e-168)
(* y (* x z))
(if (<= i 2e-88)
(* (* z b) (- c))
(if (<= i 4.4e-50)
(* x (* y z))
(if (<= i 1.9e+107)
t_1
(if (<= i 3.1e+165) (* b (* a i)) (* (* i j) (- y))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (i <= -4e+46) {
tmp = j * (y * -i);
} else if (i <= -1.6e-122) {
tmp = z * (x * y);
} else if (i <= 1.2e-264) {
tmp = t_1;
} else if (i <= 7.8e-168) {
tmp = y * (x * z);
} else if (i <= 2e-88) {
tmp = (z * b) * -c;
} else if (i <= 4.4e-50) {
tmp = x * (y * z);
} else if (i <= 1.9e+107) {
tmp = t_1;
} else if (i <= 3.1e+165) {
tmp = b * (a * i);
} else {
tmp = (i * j) * -y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = -a * (x * t)
if (i <= (-4d+46)) then
tmp = j * (y * -i)
else if (i <= (-1.6d-122)) then
tmp = z * (x * y)
else if (i <= 1.2d-264) then
tmp = t_1
else if (i <= 7.8d-168) then
tmp = y * (x * z)
else if (i <= 2d-88) then
tmp = (z * b) * -c
else if (i <= 4.4d-50) then
tmp = x * (y * z)
else if (i <= 1.9d+107) then
tmp = t_1
else if (i <= 3.1d+165) then
tmp = b * (a * i)
else
tmp = (i * j) * -y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (i <= -4e+46) {
tmp = j * (y * -i);
} else if (i <= -1.6e-122) {
tmp = z * (x * y);
} else if (i <= 1.2e-264) {
tmp = t_1;
} else if (i <= 7.8e-168) {
tmp = y * (x * z);
} else if (i <= 2e-88) {
tmp = (z * b) * -c;
} else if (i <= 4.4e-50) {
tmp = x * (y * z);
} else if (i <= 1.9e+107) {
tmp = t_1;
} else if (i <= 3.1e+165) {
tmp = b * (a * i);
} else {
tmp = (i * j) * -y;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) tmp = 0 if i <= -4e+46: tmp = j * (y * -i) elif i <= -1.6e-122: tmp = z * (x * y) elif i <= 1.2e-264: tmp = t_1 elif i <= 7.8e-168: tmp = y * (x * z) elif i <= 2e-88: tmp = (z * b) * -c elif i <= 4.4e-50: tmp = x * (y * z) elif i <= 1.9e+107: tmp = t_1 elif i <= 3.1e+165: tmp = b * (a * i) else: tmp = (i * j) * -y return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) tmp = 0.0 if (i <= -4e+46) tmp = Float64(j * Float64(y * Float64(-i))); elseif (i <= -1.6e-122) tmp = Float64(z * Float64(x * y)); elseif (i <= 1.2e-264) tmp = t_1; elseif (i <= 7.8e-168) tmp = Float64(y * Float64(x * z)); elseif (i <= 2e-88) tmp = Float64(Float64(z * b) * Float64(-c)); elseif (i <= 4.4e-50) tmp = Float64(x * Float64(y * z)); elseif (i <= 1.9e+107) tmp = t_1; elseif (i <= 3.1e+165) tmp = Float64(b * Float64(a * i)); else tmp = Float64(Float64(i * j) * Float64(-y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = -a * (x * t); tmp = 0.0; if (i <= -4e+46) tmp = j * (y * -i); elseif (i <= -1.6e-122) tmp = z * (x * y); elseif (i <= 1.2e-264) tmp = t_1; elseif (i <= 7.8e-168) tmp = y * (x * z); elseif (i <= 2e-88) tmp = (z * b) * -c; elseif (i <= 4.4e-50) tmp = x * (y * z); elseif (i <= 1.9e+107) tmp = t_1; elseif (i <= 3.1e+165) tmp = b * (a * i); else tmp = (i * j) * -y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -4e+46], N[(j * N[(y * (-i)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.6e-122], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.2e-264], t$95$1, If[LessEqual[i, 7.8e-168], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2e-88], N[(N[(z * b), $MachinePrecision] * (-c)), $MachinePrecision], If[LessEqual[i, 4.4e-50], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.9e+107], t$95$1, If[LessEqual[i, 3.1e+165], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(N[(i * j), $MachinePrecision] * (-y)), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{if}\;i \leq -4 \cdot 10^{+46}:\\
\;\;\;\;j \cdot \left(y \cdot \left(-i\right)\right)\\
\mathbf{elif}\;i \leq -1.6 \cdot 10^{-122}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;i \leq 1.2 \cdot 10^{-264}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 7.8 \cdot 10^{-168}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;i \leq 2 \cdot 10^{-88}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \left(-c\right)\\
\mathbf{elif}\;i \leq 4.4 \cdot 10^{-50}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;i \leq 1.9 \cdot 10^{+107}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 3.1 \cdot 10^{+165}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot j\right) \cdot \left(-y\right)\\
\end{array}
\end{array}
if i < -4e46Initial program 61.6%
cancel-sign-sub61.6%
cancel-sign-sub-inv61.6%
*-commutative61.6%
*-commutative61.6%
remove-double-neg61.6%
*-commutative61.6%
*-commutative61.6%
Simplified61.6%
Taylor expanded in y around inf 46.8%
+-commutative46.8%
mul-1-neg46.8%
unsub-neg46.8%
Simplified46.8%
Taylor expanded in z around 0 33.5%
mul-1-neg33.5%
*-commutative33.5%
distribute-lft-neg-in33.5%
distribute-lft-neg-in33.5%
*-commutative33.5%
associate-*l*38.3%
distribute-lft-neg-in38.3%
distribute-rgt-neg-in38.3%
Simplified38.3%
if -4e46 < i < -1.6000000000000001e-122Initial program 72.2%
cancel-sign-sub72.2%
cancel-sign-sub-inv72.2%
*-commutative72.2%
*-commutative72.2%
remove-double-neg72.2%
*-commutative72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in b around 0 63.2%
Taylor expanded in c around inf 54.1%
associate-*r*48.0%
Simplified48.0%
Taylor expanded in t around 0 41.7%
associate-*r*36.0%
*-commutative36.0%
associate-*l*41.9%
Simplified41.9%
if -1.6000000000000001e-122 < i < 1.1999999999999999e-264 or 4.3999999999999998e-50 < i < 1.8999999999999999e107Initial program 80.6%
cancel-sign-sub80.6%
cancel-sign-sub-inv80.6%
*-commutative80.6%
*-commutative80.6%
remove-double-neg80.6%
*-commutative80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in a around inf 56.3%
distribute-lft-out--56.3%
distribute-lft-out--56.3%
sub-neg56.3%
mul-1-neg56.3%
remove-double-neg56.3%
+-commutative56.3%
mul-1-neg56.3%
unsub-neg56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in b around 0 43.9%
neg-mul-143.9%
distribute-lft-neg-in43.9%
*-commutative43.9%
Simplified43.9%
if 1.1999999999999999e-264 < i < 7.80000000000000025e-168Initial program 75.6%
cancel-sign-sub75.6%
cancel-sign-sub-inv75.6%
*-commutative75.6%
*-commutative75.6%
remove-double-neg75.6%
*-commutative75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in y around inf 46.7%
+-commutative46.7%
mul-1-neg46.7%
unsub-neg46.7%
Simplified46.7%
Taylor expanded in z around inf 46.7%
if 7.80000000000000025e-168 < i < 1.99999999999999987e-88Initial program 93.2%
+-commutative93.2%
fma-def93.2%
*-commutative93.2%
*-commutative93.2%
*-commutative93.2%
*-commutative93.2%
Simplified93.2%
Taylor expanded in j around 0 72.7%
Taylor expanded in c around inf 38.3%
mul-1-neg38.3%
distribute-rgt-neg-in38.3%
*-commutative38.3%
Simplified38.3%
if 1.99999999999999987e-88 < i < 4.3999999999999998e-50Initial program 100.0%
cancel-sign-sub100.0%
cancel-sign-sub-inv100.0%
*-commutative100.0%
*-commutative100.0%
remove-double-neg100.0%
*-commutative100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in b around 0 72.5%
Taylor expanded in c around inf 72.5%
associate-*r*72.5%
Simplified72.5%
Taylor expanded in t around 0 71.5%
*-commutative71.5%
*-commutative71.5%
associate-*l*71.5%
Simplified71.5%
if 1.8999999999999999e107 < i < 3.1000000000000002e165Initial program 81.2%
cancel-sign-sub81.2%
cancel-sign-sub-inv81.2%
*-commutative81.2%
*-commutative81.2%
remove-double-neg81.2%
*-commutative81.2%
*-commutative81.2%
Simplified81.2%
Taylor expanded in b around inf 88.0%
Taylor expanded in a around inf 81.5%
if 3.1000000000000002e165 < i Initial program 66.7%
cancel-sign-sub66.7%
cancel-sign-sub-inv66.7%
*-commutative66.7%
*-commutative66.7%
remove-double-neg66.7%
*-commutative66.7%
*-commutative66.7%
Simplified66.7%
Taylor expanded in y around inf 80.1%
+-commutative80.1%
mul-1-neg80.1%
unsub-neg80.1%
Simplified80.1%
Taylor expanded in z around 0 67.2%
neg-mul-167.2%
distribute-rgt-neg-in67.2%
Simplified67.2%
Final simplification48.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))))
(if (<= i -2.65e+44)
(* j (* y (- i)))
(if (<= i -8.6e-123)
(* z (* x y))
(if (<= i 1.6e-265)
t_1
(if (<= i 1.35e-168)
(* y (* x z))
(if (<= i 2.16e-88)
(* b (* z (- c)))
(if (<= i 1.35e-48)
(* x (* y z))
(if (<= i 1.4e+107)
t_1
(if (<= i 1.15e+165) (* b (* a i)) (* (* i j) (- y))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (i <= -2.65e+44) {
tmp = j * (y * -i);
} else if (i <= -8.6e-123) {
tmp = z * (x * y);
} else if (i <= 1.6e-265) {
tmp = t_1;
} else if (i <= 1.35e-168) {
tmp = y * (x * z);
} else if (i <= 2.16e-88) {
tmp = b * (z * -c);
} else if (i <= 1.35e-48) {
tmp = x * (y * z);
} else if (i <= 1.4e+107) {
tmp = t_1;
} else if (i <= 1.15e+165) {
tmp = b * (a * i);
} else {
tmp = (i * j) * -y;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = -a * (x * t)
if (i <= (-2.65d+44)) then
tmp = j * (y * -i)
else if (i <= (-8.6d-123)) then
tmp = z * (x * y)
else if (i <= 1.6d-265) then
tmp = t_1
else if (i <= 1.35d-168) then
tmp = y * (x * z)
else if (i <= 2.16d-88) then
tmp = b * (z * -c)
else if (i <= 1.35d-48) then
tmp = x * (y * z)
else if (i <= 1.4d+107) then
tmp = t_1
else if (i <= 1.15d+165) then
tmp = b * (a * i)
else
tmp = (i * j) * -y
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (i <= -2.65e+44) {
tmp = j * (y * -i);
} else if (i <= -8.6e-123) {
tmp = z * (x * y);
} else if (i <= 1.6e-265) {
tmp = t_1;
} else if (i <= 1.35e-168) {
tmp = y * (x * z);
} else if (i <= 2.16e-88) {
tmp = b * (z * -c);
} else if (i <= 1.35e-48) {
tmp = x * (y * z);
} else if (i <= 1.4e+107) {
tmp = t_1;
} else if (i <= 1.15e+165) {
tmp = b * (a * i);
} else {
tmp = (i * j) * -y;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) tmp = 0 if i <= -2.65e+44: tmp = j * (y * -i) elif i <= -8.6e-123: tmp = z * (x * y) elif i <= 1.6e-265: tmp = t_1 elif i <= 1.35e-168: tmp = y * (x * z) elif i <= 2.16e-88: tmp = b * (z * -c) elif i <= 1.35e-48: tmp = x * (y * z) elif i <= 1.4e+107: tmp = t_1 elif i <= 1.15e+165: tmp = b * (a * i) else: tmp = (i * j) * -y return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) tmp = 0.0 if (i <= -2.65e+44) tmp = Float64(j * Float64(y * Float64(-i))); elseif (i <= -8.6e-123) tmp = Float64(z * Float64(x * y)); elseif (i <= 1.6e-265) tmp = t_1; elseif (i <= 1.35e-168) tmp = Float64(y * Float64(x * z)); elseif (i <= 2.16e-88) tmp = Float64(b * Float64(z * Float64(-c))); elseif (i <= 1.35e-48) tmp = Float64(x * Float64(y * z)); elseif (i <= 1.4e+107) tmp = t_1; elseif (i <= 1.15e+165) tmp = Float64(b * Float64(a * i)); else tmp = Float64(Float64(i * j) * Float64(-y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = -a * (x * t); tmp = 0.0; if (i <= -2.65e+44) tmp = j * (y * -i); elseif (i <= -8.6e-123) tmp = z * (x * y); elseif (i <= 1.6e-265) tmp = t_1; elseif (i <= 1.35e-168) tmp = y * (x * z); elseif (i <= 2.16e-88) tmp = b * (z * -c); elseif (i <= 1.35e-48) tmp = x * (y * z); elseif (i <= 1.4e+107) tmp = t_1; elseif (i <= 1.15e+165) tmp = b * (a * i); else tmp = (i * j) * -y; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.65e+44], N[(j * N[(y * (-i)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -8.6e-123], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.6e-265], t$95$1, If[LessEqual[i, 1.35e-168], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.16e-88], N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.35e-48], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.4e+107], t$95$1, If[LessEqual[i, 1.15e+165], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(N[(i * j), $MachinePrecision] * (-y)), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{if}\;i \leq -2.65 \cdot 10^{+44}:\\
\;\;\;\;j \cdot \left(y \cdot \left(-i\right)\right)\\
\mathbf{elif}\;i \leq -8.6 \cdot 10^{-123}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;i \leq 1.6 \cdot 10^{-265}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 1.35 \cdot 10^{-168}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;i \leq 2.16 \cdot 10^{-88}:\\
\;\;\;\;b \cdot \left(z \cdot \left(-c\right)\right)\\
\mathbf{elif}\;i \leq 1.35 \cdot 10^{-48}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;i \leq 1.4 \cdot 10^{+107}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 1.15 \cdot 10^{+165}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;\left(i \cdot j\right) \cdot \left(-y\right)\\
\end{array}
\end{array}
if i < -2.65e44Initial program 61.6%
cancel-sign-sub61.6%
cancel-sign-sub-inv61.6%
*-commutative61.6%
*-commutative61.6%
remove-double-neg61.6%
*-commutative61.6%
*-commutative61.6%
Simplified61.6%
Taylor expanded in y around inf 46.8%
+-commutative46.8%
mul-1-neg46.8%
unsub-neg46.8%
Simplified46.8%
Taylor expanded in z around 0 33.5%
mul-1-neg33.5%
*-commutative33.5%
distribute-lft-neg-in33.5%
distribute-lft-neg-in33.5%
*-commutative33.5%
associate-*l*38.3%
distribute-lft-neg-in38.3%
distribute-rgt-neg-in38.3%
Simplified38.3%
if -2.65e44 < i < -8.60000000000000064e-123Initial program 72.2%
cancel-sign-sub72.2%
cancel-sign-sub-inv72.2%
*-commutative72.2%
*-commutative72.2%
remove-double-neg72.2%
*-commutative72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in b around 0 63.2%
Taylor expanded in c around inf 54.1%
associate-*r*48.0%
Simplified48.0%
Taylor expanded in t around 0 41.7%
associate-*r*36.0%
*-commutative36.0%
associate-*l*41.9%
Simplified41.9%
if -8.60000000000000064e-123 < i < 1.6e-265 or 1.35000000000000006e-48 < i < 1.39999999999999992e107Initial program 80.6%
cancel-sign-sub80.6%
cancel-sign-sub-inv80.6%
*-commutative80.6%
*-commutative80.6%
remove-double-neg80.6%
*-commutative80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in a around inf 56.3%
distribute-lft-out--56.3%
distribute-lft-out--56.3%
sub-neg56.3%
mul-1-neg56.3%
remove-double-neg56.3%
+-commutative56.3%
mul-1-neg56.3%
unsub-neg56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in b around 0 43.9%
neg-mul-143.9%
distribute-lft-neg-in43.9%
*-commutative43.9%
Simplified43.9%
if 1.6e-265 < i < 1.35000000000000008e-168Initial program 75.6%
cancel-sign-sub75.6%
cancel-sign-sub-inv75.6%
*-commutative75.6%
*-commutative75.6%
remove-double-neg75.6%
*-commutative75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in y around inf 46.7%
+-commutative46.7%
mul-1-neg46.7%
unsub-neg46.7%
Simplified46.7%
Taylor expanded in z around inf 46.7%
if 1.35000000000000008e-168 < i < 2.1599999999999999e-88Initial program 93.2%
cancel-sign-sub93.2%
cancel-sign-sub-inv93.2%
*-commutative93.2%
*-commutative93.2%
remove-double-neg93.2%
*-commutative93.2%
*-commutative93.2%
Simplified93.2%
Taylor expanded in b around inf 51.9%
Taylor expanded in a around 0 44.9%
neg-mul-144.9%
distribute-rgt-neg-in44.9%
Simplified44.9%
if 2.1599999999999999e-88 < i < 1.35000000000000006e-48Initial program 100.0%
cancel-sign-sub100.0%
cancel-sign-sub-inv100.0%
*-commutative100.0%
*-commutative100.0%
remove-double-neg100.0%
*-commutative100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in b around 0 72.5%
Taylor expanded in c around inf 72.5%
associate-*r*72.5%
Simplified72.5%
Taylor expanded in t around 0 71.5%
*-commutative71.5%
*-commutative71.5%
associate-*l*71.5%
Simplified71.5%
if 1.39999999999999992e107 < i < 1.15000000000000008e165Initial program 81.2%
cancel-sign-sub81.2%
cancel-sign-sub-inv81.2%
*-commutative81.2%
*-commutative81.2%
remove-double-neg81.2%
*-commutative81.2%
*-commutative81.2%
Simplified81.2%
Taylor expanded in b around inf 88.0%
Taylor expanded in a around inf 81.5%
if 1.15000000000000008e165 < i Initial program 66.7%
cancel-sign-sub66.7%
cancel-sign-sub-inv66.7%
*-commutative66.7%
*-commutative66.7%
remove-double-neg66.7%
*-commutative66.7%
*-commutative66.7%
Simplified66.7%
Taylor expanded in y around inf 80.1%
+-commutative80.1%
mul-1-neg80.1%
unsub-neg80.1%
Simplified80.1%
Taylor expanded in z around 0 67.2%
neg-mul-167.2%
distribute-rgt-neg-in67.2%
Simplified67.2%
Final simplification48.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -6.8e+142)
t_2
(if (<= t -1.8e+119)
t_1
(if (<= t -3.8e-25)
t_2
(if (<= t 1.96e-303)
t_1
(if (<= t 5e-243) (* z (* x y)) (if (<= t 0.05) 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 * ((a * b) - (y * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -6.8e+142) {
tmp = t_2;
} else if (t <= -1.8e+119) {
tmp = t_1;
} else if (t <= -3.8e-25) {
tmp = t_2;
} else if (t <= 1.96e-303) {
tmp = t_1;
} else if (t <= 5e-243) {
tmp = z * (x * y);
} else if (t <= 0.05) {
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 * ((a * b) - (y * j))
t_2 = t * ((c * j) - (x * a))
if (t <= (-6.8d+142)) then
tmp = t_2
else if (t <= (-1.8d+119)) then
tmp = t_1
else if (t <= (-3.8d-25)) then
tmp = t_2
else if (t <= 1.96d-303) then
tmp = t_1
else if (t <= 5d-243) then
tmp = z * (x * y)
else if (t <= 0.05d0) 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 * ((a * b) - (y * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -6.8e+142) {
tmp = t_2;
} else if (t <= -1.8e+119) {
tmp = t_1;
} else if (t <= -3.8e-25) {
tmp = t_2;
} else if (t <= 1.96e-303) {
tmp = t_1;
} else if (t <= 5e-243) {
tmp = z * (x * y);
} else if (t <= 0.05) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((a * b) - (y * j)) t_2 = t * ((c * j) - (x * a)) tmp = 0 if t <= -6.8e+142: tmp = t_2 elif t <= -1.8e+119: tmp = t_1 elif t <= -3.8e-25: tmp = t_2 elif t <= 1.96e-303: tmp = t_1 elif t <= 5e-243: tmp = z * (x * y) elif t <= 0.05: 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(Float64(a * b) - Float64(y * j))) t_2 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -6.8e+142) tmp = t_2; elseif (t <= -1.8e+119) tmp = t_1; elseif (t <= -3.8e-25) tmp = t_2; elseif (t <= 1.96e-303) tmp = t_1; elseif (t <= 5e-243) tmp = Float64(z * Float64(x * y)); elseif (t <= 0.05) 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 * ((a * b) - (y * j)); t_2 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -6.8e+142) tmp = t_2; elseif (t <= -1.8e+119) tmp = t_1; elseif (t <= -3.8e-25) tmp = t_2; elseif (t <= 1.96e-303) tmp = t_1; elseif (t <= 5e-243) tmp = z * (x * y); elseif (t <= 0.05) 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[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -6.8e+142], t$95$2, If[LessEqual[t, -1.8e+119], t$95$1, If[LessEqual[t, -3.8e-25], t$95$2, If[LessEqual[t, 1.96e-303], t$95$1, If[LessEqual[t, 5e-243], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.05], t$95$1, t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
t_2 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -6.8 \cdot 10^{+142}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{+119}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -3.8 \cdot 10^{-25}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 1.96 \cdot 10^{-303}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-243}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;t \leq 0.05:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -6.7999999999999996e142 or -1.80000000000000001e119 < t < -3.7999999999999998e-25 or 0.050000000000000003 < t Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in t around inf 65.6%
*-commutative65.6%
mul-1-neg65.6%
unsub-neg65.6%
Simplified65.6%
if -6.7999999999999996e142 < t < -1.80000000000000001e119 or -3.7999999999999998e-25 < t < 1.9600000000000001e-303 or 5e-243 < t < 0.050000000000000003Initial program 80.4%
cancel-sign-sub80.4%
cancel-sign-sub-inv80.4%
*-commutative80.4%
*-commutative80.4%
remove-double-neg80.4%
*-commutative80.4%
*-commutative80.4%
Simplified80.4%
Taylor expanded in i around inf 52.6%
*-commutative52.6%
associate-*r*52.6%
neg-mul-152.6%
cancel-sign-sub52.6%
+-commutative52.6%
mul-1-neg52.6%
unsub-neg52.6%
*-commutative52.6%
Simplified52.6%
if 1.9600000000000001e-303 < t < 5e-243Initial program 69.0%
cancel-sign-sub69.0%
cancel-sign-sub-inv69.0%
*-commutative69.0%
*-commutative69.0%
remove-double-neg69.0%
*-commutative69.0%
*-commutative69.0%
Simplified69.0%
Taylor expanded in b around 0 69.3%
Taylor expanded in c around inf 84.6%
associate-*r*84.6%
Simplified84.6%
Taylor expanded in t around 0 77.1%
associate-*r*77.2%
*-commutative77.2%
associate-*l*77.3%
Simplified77.3%
Final simplification59.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j))))
(t_2 (* y (- (* x z) (* i j))))
(t_3 (* t (- (* c j) (* x a)))))
(if (<= t -1.65e+143)
t_3
(if (<= t -1.8e+119)
t_2
(if (<= t -1.12e-21)
t_3
(if (<= t -5.8e-156)
t_1
(if (<= t 1.22e-263) t_2 (if (<= t 0.078) 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 = i * ((a * b) - (y * j));
double t_2 = y * ((x * z) - (i * j));
double t_3 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.65e+143) {
tmp = t_3;
} else if (t <= -1.8e+119) {
tmp = t_2;
} else if (t <= -1.12e-21) {
tmp = t_3;
} else if (t <= -5.8e-156) {
tmp = t_1;
} else if (t <= 1.22e-263) {
tmp = t_2;
} else if (t <= 0.078) {
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 = i * ((a * b) - (y * j))
t_2 = y * ((x * z) - (i * j))
t_3 = t * ((c * j) - (x * a))
if (t <= (-1.65d+143)) then
tmp = t_3
else if (t <= (-1.8d+119)) then
tmp = t_2
else if (t <= (-1.12d-21)) then
tmp = t_3
else if (t <= (-5.8d-156)) then
tmp = t_1
else if (t <= 1.22d-263) then
tmp = t_2
else if (t <= 0.078d0) 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 = i * ((a * b) - (y * j));
double t_2 = y * ((x * z) - (i * j));
double t_3 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.65e+143) {
tmp = t_3;
} else if (t <= -1.8e+119) {
tmp = t_2;
} else if (t <= -1.12e-21) {
tmp = t_3;
} else if (t <= -5.8e-156) {
tmp = t_1;
} else if (t <= 1.22e-263) {
tmp = t_2;
} else if (t <= 0.078) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((a * b) - (y * j)) t_2 = y * ((x * z) - (i * j)) t_3 = t * ((c * j) - (x * a)) tmp = 0 if t <= -1.65e+143: tmp = t_3 elif t <= -1.8e+119: tmp = t_2 elif t <= -1.12e-21: tmp = t_3 elif t <= -5.8e-156: tmp = t_1 elif t <= 1.22e-263: tmp = t_2 elif t <= 0.078: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) t_2 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) t_3 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -1.65e+143) tmp = t_3; elseif (t <= -1.8e+119) tmp = t_2; elseif (t <= -1.12e-21) tmp = t_3; elseif (t <= -5.8e-156) tmp = t_1; elseif (t <= 1.22e-263) tmp = t_2; elseif (t <= 0.078) 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 = i * ((a * b) - (y * j)); t_2 = y * ((x * z) - (i * j)); t_3 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -1.65e+143) tmp = t_3; elseif (t <= -1.8e+119) tmp = t_2; elseif (t <= -1.12e-21) tmp = t_3; elseif (t <= -5.8e-156) tmp = t_1; elseif (t <= 1.22e-263) tmp = t_2; elseif (t <= 0.078) 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[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.65e+143], t$95$3, If[LessEqual[t, -1.8e+119], t$95$2, If[LessEqual[t, -1.12e-21], t$95$3, If[LessEqual[t, -5.8e-156], t$95$1, If[LessEqual[t, 1.22e-263], t$95$2, If[LessEqual[t, 0.078], t$95$1, t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
t_2 := y \cdot \left(x \cdot z - i \cdot j\right)\\
t_3 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -1.65 \cdot 10^{+143}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -1.8 \cdot 10^{+119}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.12 \cdot 10^{-21}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;t \leq -5.8 \cdot 10^{-156}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 1.22 \cdot 10^{-263}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 0.078:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_3\\
\end{array}
\end{array}
if t < -1.65e143 or -1.80000000000000001e119 < t < -1.11999999999999998e-21 or 0.0779999999999999999 < t Initial program 68.4%
cancel-sign-sub68.4%
cancel-sign-sub-inv68.4%
*-commutative68.4%
*-commutative68.4%
remove-double-neg68.4%
*-commutative68.4%
*-commutative68.4%
Simplified68.4%
Taylor expanded in t around inf 65.6%
*-commutative65.6%
mul-1-neg65.6%
unsub-neg65.6%
Simplified65.6%
if -1.65e143 < t < -1.80000000000000001e119 or -5.80000000000000041e-156 < t < 1.22000000000000005e-263Initial program 84.8%
cancel-sign-sub84.8%
cancel-sign-sub-inv84.8%
*-commutative84.8%
*-commutative84.8%
remove-double-neg84.8%
*-commutative84.8%
*-commutative84.8%
Simplified84.8%
Taylor expanded in y around inf 65.3%
+-commutative65.3%
mul-1-neg65.3%
unsub-neg65.3%
Simplified65.3%
if -1.11999999999999998e-21 < t < -5.80000000000000041e-156 or 1.22000000000000005e-263 < t < 0.0779999999999999999Initial program 75.3%
cancel-sign-sub75.3%
cancel-sign-sub-inv75.3%
*-commutative75.3%
*-commutative75.3%
remove-double-neg75.3%
*-commutative75.3%
*-commutative75.3%
Simplified75.3%
Taylor expanded in i around inf 56.1%
*-commutative56.1%
associate-*r*56.1%
neg-mul-156.1%
cancel-sign-sub56.1%
+-commutative56.1%
mul-1-neg56.1%
unsub-neg56.1%
*-commutative56.1%
Simplified56.1%
Final simplification62.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (- (* x z) (* i j)))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -1.42e+143)
t_2
(if (<= t -1.15e+119)
t_1
(if (<= t -1.62e-24)
t_2
(if (<= t -1.85e-156)
(* i (- (* a b) (* y j)))
(if (<= t 6.5e-193)
t_1
(if (<= t 2700000000000.0) (* b (- (* a i) (* z c))) 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 = y * ((x * z) - (i * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.42e+143) {
tmp = t_2;
} else if (t <= -1.15e+119) {
tmp = t_1;
} else if (t <= -1.62e-24) {
tmp = t_2;
} else if (t <= -1.85e-156) {
tmp = i * ((a * b) - (y * j));
} else if (t <= 6.5e-193) {
tmp = t_1;
} else if (t <= 2700000000000.0) {
tmp = b * ((a * i) - (z * c));
} 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 = y * ((x * z) - (i * j))
t_2 = t * ((c * j) - (x * a))
if (t <= (-1.42d+143)) then
tmp = t_2
else if (t <= (-1.15d+119)) then
tmp = t_1
else if (t <= (-1.62d-24)) then
tmp = t_2
else if (t <= (-1.85d-156)) then
tmp = i * ((a * b) - (y * j))
else if (t <= 6.5d-193) then
tmp = t_1
else if (t <= 2700000000000.0d0) then
tmp = b * ((a * i) - (z * c))
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 = y * ((x * z) - (i * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.42e+143) {
tmp = t_2;
} else if (t <= -1.15e+119) {
tmp = t_1;
} else if (t <= -1.62e-24) {
tmp = t_2;
} else if (t <= -1.85e-156) {
tmp = i * ((a * b) - (y * j));
} else if (t <= 6.5e-193) {
tmp = t_1;
} else if (t <= 2700000000000.0) {
tmp = b * ((a * i) - (z * c));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * ((x * z) - (i * j)) t_2 = t * ((c * j) - (x * a)) tmp = 0 if t <= -1.42e+143: tmp = t_2 elif t <= -1.15e+119: tmp = t_1 elif t <= -1.62e-24: tmp = t_2 elif t <= -1.85e-156: tmp = i * ((a * b) - (y * j)) elif t <= 6.5e-193: tmp = t_1 elif t <= 2700000000000.0: tmp = b * ((a * i) - (z * c)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) t_2 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -1.42e+143) tmp = t_2; elseif (t <= -1.15e+119) tmp = t_1; elseif (t <= -1.62e-24) tmp = t_2; elseif (t <= -1.85e-156) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (t <= 6.5e-193) tmp = t_1; elseif (t <= 2700000000000.0) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * ((x * z) - (i * j)); t_2 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -1.42e+143) tmp = t_2; elseif (t <= -1.15e+119) tmp = t_1; elseif (t <= -1.62e-24) tmp = t_2; elseif (t <= -1.85e-156) tmp = i * ((a * b) - (y * j)); elseif (t <= 6.5e-193) tmp = t_1; elseif (t <= 2700000000000.0) tmp = b * ((a * i) - (z * c)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.42e+143], t$95$2, If[LessEqual[t, -1.15e+119], t$95$1, If[LessEqual[t, -1.62e-24], t$95$2, If[LessEqual[t, -1.85e-156], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.5e-193], t$95$1, If[LessEqual[t, 2700000000000.0], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z - i \cdot j\right)\\
t_2 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -1.42 \cdot 10^{+143}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.15 \cdot 10^{+119}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.62 \cdot 10^{-24}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -1.85 \cdot 10^{-156}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;t \leq 6.5 \cdot 10^{-193}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 2700000000000:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -1.42e143 or -1.15e119 < t < -1.62e-24 or 2.7e12 < t Initial program 68.2%
cancel-sign-sub68.2%
cancel-sign-sub-inv68.2%
*-commutative68.2%
*-commutative68.2%
remove-double-neg68.2%
*-commutative68.2%
*-commutative68.2%
Simplified68.2%
Taylor expanded in t around inf 67.8%
*-commutative67.8%
mul-1-neg67.8%
unsub-neg67.8%
Simplified67.8%
if -1.42e143 < t < -1.15e119 or -1.85e-156 < t < 6.5000000000000004e-193Initial program 84.5%
cancel-sign-sub84.5%
cancel-sign-sub-inv84.5%
*-commutative84.5%
*-commutative84.5%
remove-double-neg84.5%
*-commutative84.5%
*-commutative84.5%
Simplified84.5%
Taylor expanded in y around inf 63.3%
+-commutative63.3%
mul-1-neg63.3%
unsub-neg63.3%
Simplified63.3%
if -1.62e-24 < t < -1.85e-156Initial program 74.1%
cancel-sign-sub74.1%
cancel-sign-sub-inv74.1%
*-commutative74.1%
*-commutative74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in i around inf 60.9%
*-commutative60.9%
associate-*r*60.9%
neg-mul-160.9%
cancel-sign-sub60.9%
+-commutative60.9%
mul-1-neg60.9%
unsub-neg60.9%
*-commutative60.9%
Simplified60.9%
if 6.5000000000000004e-193 < t < 2.7e12Initial program 71.7%
cancel-sign-sub71.7%
cancel-sign-sub-inv71.7%
*-commutative71.7%
*-commutative71.7%
remove-double-neg71.7%
*-commutative71.7%
*-commutative71.7%
Simplified71.7%
Taylor expanded in b around inf 59.7%
Final simplification64.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (- (* x z) (* i j)))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -3.7e+143)
t_2
(if (<= t -5.8e+118)
t_1
(if (<= t -1.7e-21)
(- (* j (* t c)) (* a (* x t)))
(if (<= t -3.2e-156)
(* i (- (* a b) (* y j)))
(if (<= t 6e-193)
t_1
(if (<= t 54000000000000.0) (* b (- (* a i) (* z c))) 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 = y * ((x * z) - (i * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -3.7e+143) {
tmp = t_2;
} else if (t <= -5.8e+118) {
tmp = t_1;
} else if (t <= -1.7e-21) {
tmp = (j * (t * c)) - (a * (x * t));
} else if (t <= -3.2e-156) {
tmp = i * ((a * b) - (y * j));
} else if (t <= 6e-193) {
tmp = t_1;
} else if (t <= 54000000000000.0) {
tmp = b * ((a * i) - (z * c));
} 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 = y * ((x * z) - (i * j))
t_2 = t * ((c * j) - (x * a))
if (t <= (-3.7d+143)) then
tmp = t_2
else if (t <= (-5.8d+118)) then
tmp = t_1
else if (t <= (-1.7d-21)) then
tmp = (j * (t * c)) - (a * (x * t))
else if (t <= (-3.2d-156)) then
tmp = i * ((a * b) - (y * j))
else if (t <= 6d-193) then
tmp = t_1
else if (t <= 54000000000000.0d0) then
tmp = b * ((a * i) - (z * c))
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 = y * ((x * z) - (i * j));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -3.7e+143) {
tmp = t_2;
} else if (t <= -5.8e+118) {
tmp = t_1;
} else if (t <= -1.7e-21) {
tmp = (j * (t * c)) - (a * (x * t));
} else if (t <= -3.2e-156) {
tmp = i * ((a * b) - (y * j));
} else if (t <= 6e-193) {
tmp = t_1;
} else if (t <= 54000000000000.0) {
tmp = b * ((a * i) - (z * c));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * ((x * z) - (i * j)) t_2 = t * ((c * j) - (x * a)) tmp = 0 if t <= -3.7e+143: tmp = t_2 elif t <= -5.8e+118: tmp = t_1 elif t <= -1.7e-21: tmp = (j * (t * c)) - (a * (x * t)) elif t <= -3.2e-156: tmp = i * ((a * b) - (y * j)) elif t <= 6e-193: tmp = t_1 elif t <= 54000000000000.0: tmp = b * ((a * i) - (z * c)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) t_2 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -3.7e+143) tmp = t_2; elseif (t <= -5.8e+118) tmp = t_1; elseif (t <= -1.7e-21) tmp = Float64(Float64(j * Float64(t * c)) - Float64(a * Float64(x * t))); elseif (t <= -3.2e-156) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (t <= 6e-193) tmp = t_1; elseif (t <= 54000000000000.0) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * ((x * z) - (i * j)); t_2 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -3.7e+143) tmp = t_2; elseif (t <= -5.8e+118) tmp = t_1; elseif (t <= -1.7e-21) tmp = (j * (t * c)) - (a * (x * t)); elseif (t <= -3.2e-156) tmp = i * ((a * b) - (y * j)); elseif (t <= 6e-193) tmp = t_1; elseif (t <= 54000000000000.0) tmp = b * ((a * i) - (z * c)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.7e+143], t$95$2, If[LessEqual[t, -5.8e+118], t$95$1, If[LessEqual[t, -1.7e-21], N[(N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision] - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -3.2e-156], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6e-193], t$95$1, If[LessEqual[t, 54000000000000.0], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z - i \cdot j\right)\\
t_2 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -3.7 \cdot 10^{+143}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq -5.8 \cdot 10^{+118}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq -1.7 \cdot 10^{-21}:\\
\;\;\;\;j \cdot \left(t \cdot c\right) - a \cdot \left(x \cdot t\right)\\
\mathbf{elif}\;t \leq -3.2 \cdot 10^{-156}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;t \leq 6 \cdot 10^{-193}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t \leq 54000000000000:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -3.7000000000000002e143 or 5.4e13 < t Initial program 65.9%
cancel-sign-sub65.9%
cancel-sign-sub-inv65.9%
*-commutative65.9%
*-commutative65.9%
remove-double-neg65.9%
*-commutative65.9%
*-commutative65.9%
Simplified65.9%
Taylor expanded in t around inf 67.4%
*-commutative67.4%
mul-1-neg67.4%
unsub-neg67.4%
Simplified67.4%
if -3.7000000000000002e143 < t < -5.80000000000000032e118 or -3.19999999999999982e-156 < t < 5.9999999999999998e-193Initial program 84.5%
cancel-sign-sub84.5%
cancel-sign-sub-inv84.5%
*-commutative84.5%
*-commutative84.5%
remove-double-neg84.5%
*-commutative84.5%
*-commutative84.5%
Simplified84.5%
Taylor expanded in y around inf 63.3%
+-commutative63.3%
mul-1-neg63.3%
unsub-neg63.3%
Simplified63.3%
if -5.80000000000000032e118 < t < -1.7e-21Initial program 74.8%
cancel-sign-sub74.8%
cancel-sign-sub-inv74.8%
*-commutative74.8%
*-commutative74.8%
remove-double-neg74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in b around 0 75.6%
Taylor expanded in c around inf 68.8%
associate-*r*75.8%
Simplified75.8%
Taylor expanded in y around 0 72.5%
associate-*r*72.5%
neg-mul-172.5%
Simplified72.5%
if -1.7e-21 < t < -3.19999999999999982e-156Initial program 74.1%
cancel-sign-sub74.1%
cancel-sign-sub-inv74.1%
*-commutative74.1%
*-commutative74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in i around inf 60.9%
*-commutative60.9%
associate-*r*60.9%
neg-mul-160.9%
cancel-sign-sub60.9%
+-commutative60.9%
mul-1-neg60.9%
unsub-neg60.9%
*-commutative60.9%
Simplified60.9%
if 5.9999999999999998e-193 < t < 5.4e13Initial program 71.7%
cancel-sign-sub71.7%
cancel-sign-sub-inv71.7%
*-commutative71.7%
*-commutative71.7%
remove-double-neg71.7%
*-commutative71.7%
*-commutative71.7%
Simplified71.7%
Taylor expanded in b around inf 59.7%
Final simplification64.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t))))
(t_2 (* y (* x z)))
(t_3 (* i (- (* a b) (* y j)))))
(if (<= z -6e+116)
t_2
(if (<= z -1.35e-258)
t_1
(if (<= z 2.25e-71)
t_3
(if (<= z 3.8e+22)
t_1
(if (<= z 8.2e+180)
t_3
(if (<= z 5.4e+199) (* j (* t c)) 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 * ((b * i) - (x * t));
double t_2 = y * (x * z);
double t_3 = i * ((a * b) - (y * j));
double tmp;
if (z <= -6e+116) {
tmp = t_2;
} else if (z <= -1.35e-258) {
tmp = t_1;
} else if (z <= 2.25e-71) {
tmp = t_3;
} else if (z <= 3.8e+22) {
tmp = t_1;
} else if (z <= 8.2e+180) {
tmp = t_3;
} else if (z <= 5.4e+199) {
tmp = j * (t * c);
} 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) :: t_3
real(8) :: tmp
t_1 = a * ((b * i) - (x * t))
t_2 = y * (x * z)
t_3 = i * ((a * b) - (y * j))
if (z <= (-6d+116)) then
tmp = t_2
else if (z <= (-1.35d-258)) then
tmp = t_1
else if (z <= 2.25d-71) then
tmp = t_3
else if (z <= 3.8d+22) then
tmp = t_1
else if (z <= 8.2d+180) then
tmp = t_3
else if (z <= 5.4d+199) then
tmp = j * (t * c)
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 * ((b * i) - (x * t));
double t_2 = y * (x * z);
double t_3 = i * ((a * b) - (y * j));
double tmp;
if (z <= -6e+116) {
tmp = t_2;
} else if (z <= -1.35e-258) {
tmp = t_1;
} else if (z <= 2.25e-71) {
tmp = t_3;
} else if (z <= 3.8e+22) {
tmp = t_1;
} else if (z <= 8.2e+180) {
tmp = t_3;
} else if (z <= 5.4e+199) {
tmp = j * (t * c);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) t_2 = y * (x * z) t_3 = i * ((a * b) - (y * j)) tmp = 0 if z <= -6e+116: tmp = t_2 elif z <= -1.35e-258: tmp = t_1 elif z <= 2.25e-71: tmp = t_3 elif z <= 3.8e+22: tmp = t_1 elif z <= 8.2e+180: tmp = t_3 elif z <= 5.4e+199: tmp = j * (t * c) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) t_2 = Float64(y * Float64(x * z)) t_3 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (z <= -6e+116) tmp = t_2; elseif (z <= -1.35e-258) tmp = t_1; elseif (z <= 2.25e-71) tmp = t_3; elseif (z <= 3.8e+22) tmp = t_1; elseif (z <= 8.2e+180) tmp = t_3; elseif (z <= 5.4e+199) tmp = Float64(j * Float64(t * c)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); t_2 = y * (x * z); t_3 = i * ((a * b) - (y * j)); tmp = 0.0; if (z <= -6e+116) tmp = t_2; elseif (z <= -1.35e-258) tmp = t_1; elseif (z <= 2.25e-71) tmp = t_3; elseif (z <= 3.8e+22) tmp = t_1; elseif (z <= 8.2e+180) tmp = t_3; elseif (z <= 5.4e+199) tmp = j * (t * c); 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[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6e+116], t$95$2, If[LessEqual[z, -1.35e-258], t$95$1, If[LessEqual[z, 2.25e-71], t$95$3, If[LessEqual[z, 3.8e+22], t$95$1, If[LessEqual[z, 8.2e+180], t$95$3, If[LessEqual[z, 5.4e+199], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
t_2 := y \cdot \left(x \cdot z\right)\\
t_3 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;z \leq -6 \cdot 10^{+116}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;z \leq -1.35 \cdot 10^{-258}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{-71}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;z \leq 3.8 \cdot 10^{+22}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+180}:\\
\;\;\;\;t_3\\
\mathbf{elif}\;z \leq 5.4 \cdot 10^{+199}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if z < -5.9999999999999997e116 or 5.3999999999999998e199 < z Initial program 61.3%
cancel-sign-sub61.3%
cancel-sign-sub-inv61.3%
*-commutative61.3%
*-commutative61.3%
remove-double-neg61.3%
*-commutative61.3%
*-commutative61.3%
Simplified61.3%
Taylor expanded in y around inf 61.8%
+-commutative61.8%
mul-1-neg61.8%
unsub-neg61.8%
Simplified61.8%
Taylor expanded in z around inf 54.4%
if -5.9999999999999997e116 < z < -1.34999999999999998e-258 or 2.2500000000000001e-71 < z < 3.8000000000000004e22Initial program 86.6%
cancel-sign-sub86.6%
cancel-sign-sub-inv86.6%
*-commutative86.6%
*-commutative86.6%
remove-double-neg86.6%
*-commutative86.6%
*-commutative86.6%
Simplified86.6%
Taylor expanded in a around inf 59.7%
distribute-lft-out--59.7%
distribute-lft-out--59.7%
sub-neg59.7%
mul-1-neg59.7%
remove-double-neg59.7%
+-commutative59.7%
mul-1-neg59.7%
unsub-neg59.7%
*-commutative59.7%
Simplified59.7%
if -1.34999999999999998e-258 < z < 2.2500000000000001e-71 or 3.8000000000000004e22 < z < 8.2e180Initial program 74.2%
cancel-sign-sub74.2%
cancel-sign-sub-inv74.2%
*-commutative74.2%
*-commutative74.2%
remove-double-neg74.2%
*-commutative74.2%
*-commutative74.2%
Simplified74.2%
Taylor expanded in i around inf 53.9%
*-commutative53.9%
associate-*r*53.9%
neg-mul-153.9%
cancel-sign-sub53.9%
+-commutative53.9%
mul-1-neg53.9%
unsub-neg53.9%
*-commutative53.9%
Simplified53.9%
if 8.2e180 < z < 5.3999999999999998e199Initial program 60.0%
cancel-sign-sub60.0%
cancel-sign-sub-inv60.0%
*-commutative60.0%
*-commutative60.0%
remove-double-neg60.0%
*-commutative60.0%
*-commutative60.0%
Simplified60.0%
Taylor expanded in b around 0 60.0%
Taylor expanded in j around inf 80.0%
Taylor expanded in c around inf 80.0%
Final simplification56.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= j -1.4e+105)
t_1
(if (<= j -8.2e-39)
(+ (* z (* x y)) (* b (* a i)))
(if (<= j -1.8e-247)
(* x (- (* y z) (* t a)))
(if (<= j 1.45e-199)
(* b (- (* a i) (* z c)))
(if (<= j 2.2e+141) (* y (- (* x z) (* 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 = j * ((t * c) - (y * i));
double tmp;
if (j <= -1.4e+105) {
tmp = t_1;
} else if (j <= -8.2e-39) {
tmp = (z * (x * y)) + (b * (a * i));
} else if (j <= -1.8e-247) {
tmp = x * ((y * z) - (t * a));
} else if (j <= 1.45e-199) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 2.2e+141) {
tmp = y * ((x * z) - (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 = j * ((t * c) - (y * i))
if (j <= (-1.4d+105)) then
tmp = t_1
else if (j <= (-8.2d-39)) then
tmp = (z * (x * y)) + (b * (a * i))
else if (j <= (-1.8d-247)) then
tmp = x * ((y * z) - (t * a))
else if (j <= 1.45d-199) then
tmp = b * ((a * i) - (z * c))
else if (j <= 2.2d+141) then
tmp = y * ((x * z) - (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 = j * ((t * c) - (y * i));
double tmp;
if (j <= -1.4e+105) {
tmp = t_1;
} else if (j <= -8.2e-39) {
tmp = (z * (x * y)) + (b * (a * i));
} else if (j <= -1.8e-247) {
tmp = x * ((y * z) - (t * a));
} else if (j <= 1.45e-199) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 2.2e+141) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) tmp = 0 if j <= -1.4e+105: tmp = t_1 elif j <= -8.2e-39: tmp = (z * (x * y)) + (b * (a * i)) elif j <= -1.8e-247: tmp = x * ((y * z) - (t * a)) elif j <= 1.45e-199: tmp = b * ((a * i) - (z * c)) elif j <= 2.2e+141: tmp = y * ((x * z) - (i * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -1.4e+105) tmp = t_1; elseif (j <= -8.2e-39) tmp = Float64(Float64(z * Float64(x * y)) + Float64(b * Float64(a * i))); elseif (j <= -1.8e-247) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (j <= 1.45e-199) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (j <= 2.2e+141) tmp = Float64(y * Float64(Float64(x * z) - 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 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -1.4e+105) tmp = t_1; elseif (j <= -8.2e-39) tmp = (z * (x * y)) + (b * (a * i)); elseif (j <= -1.8e-247) tmp = x * ((y * z) - (t * a)); elseif (j <= 1.45e-199) tmp = b * ((a * i) - (z * c)); elseif (j <= 2.2e+141) tmp = y * ((x * z) - (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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.4e+105], t$95$1, If[LessEqual[j, -8.2e-39], N[(N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -1.8e-247], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.45e-199], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.2e+141], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -1.4 \cdot 10^{+105}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;j \leq -8.2 \cdot 10^{-39}:\\
\;\;\;\;z \cdot \left(x \cdot y\right) + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;j \leq -1.8 \cdot 10^{-247}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;j \leq 1.45 \cdot 10^{-199}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 2.2 \cdot 10^{+141}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if j < -1.4000000000000001e105 or 2.2e141 < j Initial program 77.4%
cancel-sign-sub77.4%
cancel-sign-sub-inv77.4%
*-commutative77.4%
*-commutative77.4%
remove-double-neg77.4%
*-commutative77.4%
*-commutative77.4%
Simplified77.4%
Taylor expanded in b around 0 73.8%
Taylor expanded in j around inf 71.0%
if -1.4000000000000001e105 < j < -8.2e-39Initial program 79.4%
+-commutative79.4%
fma-def79.4%
*-commutative79.4%
*-commutative79.4%
*-commutative79.4%
*-commutative79.4%
Simplified79.4%
Taylor expanded in j around 0 76.4%
Taylor expanded in y around inf 79.6%
*-commutative79.6%
associate-*l*79.9%
Simplified79.9%
Taylor expanded in c around 0 69.6%
neg-mul-169.6%
distribute-rgt-neg-in69.6%
Simplified69.6%
if -8.2e-39 < j < -1.7999999999999998e-247Initial program 69.6%
+-commutative69.6%
fma-def69.6%
*-commutative69.6%
*-commutative69.6%
*-commutative69.6%
*-commutative69.6%
Simplified69.6%
Taylor expanded in j around 0 77.9%
Taylor expanded in x around inf 70.0%
if -1.7999999999999998e-247 < j < 1.45e-199Initial program 75.4%
cancel-sign-sub75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
*-commutative75.4%
remove-double-neg75.4%
*-commutative75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in b around inf 55.7%
if 1.45e-199 < j < 2.2e141Initial program 71.1%
cancel-sign-sub71.1%
cancel-sign-sub-inv71.1%
*-commutative71.1%
*-commutative71.1%
remove-double-neg71.1%
*-commutative71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in y around inf 59.7%
+-commutative59.7%
mul-1-neg59.7%
unsub-neg59.7%
Simplified59.7%
Final simplification65.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))))
(if (<= b -1.42e+17)
(* (* z b) (- c))
(if (<= b -1.8e-31)
t_1
(if (<= b -1.9e-158)
(* y (* x z))
(if (<= b 1.9e-210)
t_1
(if (<= b 5.6e-161)
(* x (* y z))
(if (<= b 185.0) t_1 (* b (* a i))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (b <= -1.42e+17) {
tmp = (z * b) * -c;
} else if (b <= -1.8e-31) {
tmp = t_1;
} else if (b <= -1.9e-158) {
tmp = y * (x * z);
} else if (b <= 1.9e-210) {
tmp = t_1;
} else if (b <= 5.6e-161) {
tmp = x * (y * z);
} else if (b <= 185.0) {
tmp = t_1;
} else {
tmp = b * (a * 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) :: t_1
real(8) :: tmp
t_1 = -a * (x * t)
if (b <= (-1.42d+17)) then
tmp = (z * b) * -c
else if (b <= (-1.8d-31)) then
tmp = t_1
else if (b <= (-1.9d-158)) then
tmp = y * (x * z)
else if (b <= 1.9d-210) then
tmp = t_1
else if (b <= 5.6d-161) then
tmp = x * (y * z)
else if (b <= 185.0d0) then
tmp = t_1
else
tmp = b * (a * 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 t_1 = -a * (x * t);
double tmp;
if (b <= -1.42e+17) {
tmp = (z * b) * -c;
} else if (b <= -1.8e-31) {
tmp = t_1;
} else if (b <= -1.9e-158) {
tmp = y * (x * z);
} else if (b <= 1.9e-210) {
tmp = t_1;
} else if (b <= 5.6e-161) {
tmp = x * (y * z);
} else if (b <= 185.0) {
tmp = t_1;
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) tmp = 0 if b <= -1.42e+17: tmp = (z * b) * -c elif b <= -1.8e-31: tmp = t_1 elif b <= -1.9e-158: tmp = y * (x * z) elif b <= 1.9e-210: tmp = t_1 elif b <= 5.6e-161: tmp = x * (y * z) elif b <= 185.0: tmp = t_1 else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) tmp = 0.0 if (b <= -1.42e+17) tmp = Float64(Float64(z * b) * Float64(-c)); elseif (b <= -1.8e-31) tmp = t_1; elseif (b <= -1.9e-158) tmp = Float64(y * Float64(x * z)); elseif (b <= 1.9e-210) tmp = t_1; elseif (b <= 5.6e-161) tmp = Float64(x * Float64(y * z)); elseif (b <= 185.0) tmp = t_1; else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = -a * (x * t); tmp = 0.0; if (b <= -1.42e+17) tmp = (z * b) * -c; elseif (b <= -1.8e-31) tmp = t_1; elseif (b <= -1.9e-158) tmp = y * (x * z); elseif (b <= 1.9e-210) tmp = t_1; elseif (b <= 5.6e-161) tmp = x * (y * z); elseif (b <= 185.0) tmp = t_1; else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.42e+17], N[(N[(z * b), $MachinePrecision] * (-c)), $MachinePrecision], If[LessEqual[b, -1.8e-31], t$95$1, If[LessEqual[b, -1.9e-158], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.9e-210], t$95$1, If[LessEqual[b, 5.6e-161], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 185.0], t$95$1, N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{if}\;b \leq -1.42 \cdot 10^{+17}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \left(-c\right)\\
\mathbf{elif}\;b \leq -1.8 \cdot 10^{-31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -1.9 \cdot 10^{-158}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;b \leq 1.9 \cdot 10^{-210}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 5.6 \cdot 10^{-161}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;b \leq 185:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if b < -1.42e17Initial program 76.7%
+-commutative76.7%
fma-def76.7%
*-commutative76.7%
*-commutative76.7%
*-commutative76.7%
*-commutative76.7%
Simplified76.7%
Taylor expanded in j around 0 67.9%
Taylor expanded in c around inf 39.1%
mul-1-neg39.1%
distribute-rgt-neg-in39.1%
*-commutative39.1%
Simplified39.1%
if -1.42e17 < b < -1.80000000000000002e-31 or -1.8999999999999999e-158 < b < 1.90000000000000002e-210 or 5.59999999999999984e-161 < b < 185Initial program 73.5%
cancel-sign-sub73.5%
cancel-sign-sub-inv73.5%
*-commutative73.5%
*-commutative73.5%
remove-double-neg73.5%
*-commutative73.5%
*-commutative73.5%
Simplified73.5%
Taylor expanded in a around inf 51.8%
distribute-lft-out--51.8%
distribute-lft-out--51.8%
sub-neg51.8%
mul-1-neg51.8%
remove-double-neg51.8%
+-commutative51.8%
mul-1-neg51.8%
unsub-neg51.8%
*-commutative51.8%
Simplified51.8%
Taylor expanded in b around 0 44.7%
neg-mul-144.7%
distribute-lft-neg-in44.7%
*-commutative44.7%
Simplified44.7%
if -1.80000000000000002e-31 < b < -1.8999999999999999e-158Initial program 69.5%
cancel-sign-sub69.5%
cancel-sign-sub-inv69.5%
*-commutative69.5%
*-commutative69.5%
remove-double-neg69.5%
*-commutative69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in y around inf 62.5%
+-commutative62.5%
mul-1-neg62.5%
unsub-neg62.5%
Simplified62.5%
Taylor expanded in z around inf 45.5%
if 1.90000000000000002e-210 < b < 5.59999999999999984e-161Initial program 55.1%
cancel-sign-sub55.1%
cancel-sign-sub-inv55.1%
*-commutative55.1%
*-commutative55.1%
remove-double-neg55.1%
*-commutative55.1%
*-commutative55.1%
Simplified55.1%
Taylor expanded in b around 0 55.1%
Taylor expanded in c around inf 47.5%
associate-*r*40.1%
Simplified40.1%
Taylor expanded in t around 0 40.6%
*-commutative40.6%
*-commutative40.6%
associate-*l*47.5%
Simplified47.5%
if 185 < b Initial program 80.2%
cancel-sign-sub80.2%
cancel-sign-sub-inv80.2%
*-commutative80.2%
*-commutative80.2%
remove-double-neg80.2%
*-commutative80.2%
*-commutative80.2%
Simplified80.2%
Taylor expanded in b around inf 67.7%
Taylor expanded in a around inf 51.2%
Final simplification45.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))))
(if (<= b -2.45e+16)
(* (* z b) (- c))
(if (<= b -2.3e-31)
t_1
(if (<= b -2e-157)
(* y (* x z))
(if (<= b 1.11e-203)
t_1
(if (<= b 1.22e-77)
(* j (* y (- i)))
(if (<= b 206.0) t_1 (* b (* a i))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double tmp;
if (b <= -2.45e+16) {
tmp = (z * b) * -c;
} else if (b <= -2.3e-31) {
tmp = t_1;
} else if (b <= -2e-157) {
tmp = y * (x * z);
} else if (b <= 1.11e-203) {
tmp = t_1;
} else if (b <= 1.22e-77) {
tmp = j * (y * -i);
} else if (b <= 206.0) {
tmp = t_1;
} else {
tmp = b * (a * 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) :: t_1
real(8) :: tmp
t_1 = -a * (x * t)
if (b <= (-2.45d+16)) then
tmp = (z * b) * -c
else if (b <= (-2.3d-31)) then
tmp = t_1
else if (b <= (-2d-157)) then
tmp = y * (x * z)
else if (b <= 1.11d-203) then
tmp = t_1
else if (b <= 1.22d-77) then
tmp = j * (y * -i)
else if (b <= 206.0d0) then
tmp = t_1
else
tmp = b * (a * 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 t_1 = -a * (x * t);
double tmp;
if (b <= -2.45e+16) {
tmp = (z * b) * -c;
} else if (b <= -2.3e-31) {
tmp = t_1;
} else if (b <= -2e-157) {
tmp = y * (x * z);
} else if (b <= 1.11e-203) {
tmp = t_1;
} else if (b <= 1.22e-77) {
tmp = j * (y * -i);
} else if (b <= 206.0) {
tmp = t_1;
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) tmp = 0 if b <= -2.45e+16: tmp = (z * b) * -c elif b <= -2.3e-31: tmp = t_1 elif b <= -2e-157: tmp = y * (x * z) elif b <= 1.11e-203: tmp = t_1 elif b <= 1.22e-77: tmp = j * (y * -i) elif b <= 206.0: tmp = t_1 else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) tmp = 0.0 if (b <= -2.45e+16) tmp = Float64(Float64(z * b) * Float64(-c)); elseif (b <= -2.3e-31) tmp = t_1; elseif (b <= -2e-157) tmp = Float64(y * Float64(x * z)); elseif (b <= 1.11e-203) tmp = t_1; elseif (b <= 1.22e-77) tmp = Float64(j * Float64(y * Float64(-i))); elseif (b <= 206.0) tmp = t_1; else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = -a * (x * t); tmp = 0.0; if (b <= -2.45e+16) tmp = (z * b) * -c; elseif (b <= -2.3e-31) tmp = t_1; elseif (b <= -2e-157) tmp = y * (x * z); elseif (b <= 1.11e-203) tmp = t_1; elseif (b <= 1.22e-77) tmp = j * (y * -i); elseif (b <= 206.0) tmp = t_1; else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.45e+16], N[(N[(z * b), $MachinePrecision] * (-c)), $MachinePrecision], If[LessEqual[b, -2.3e-31], t$95$1, If[LessEqual[b, -2e-157], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.11e-203], t$95$1, If[LessEqual[b, 1.22e-77], N[(j * N[(y * (-i)), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 206.0], t$95$1, N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{if}\;b \leq -2.45 \cdot 10^{+16}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \left(-c\right)\\
\mathbf{elif}\;b \leq -2.3 \cdot 10^{-31}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq -2 \cdot 10^{-157}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;b \leq 1.11 \cdot 10^{-203}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;b \leq 1.22 \cdot 10^{-77}:\\
\;\;\;\;j \cdot \left(y \cdot \left(-i\right)\right)\\
\mathbf{elif}\;b \leq 206:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if b < -2.45e16Initial program 76.7%
+-commutative76.7%
fma-def76.7%
*-commutative76.7%
*-commutative76.7%
*-commutative76.7%
*-commutative76.7%
Simplified76.7%
Taylor expanded in j around 0 67.9%
Taylor expanded in c around inf 39.1%
mul-1-neg39.1%
distribute-rgt-neg-in39.1%
*-commutative39.1%
Simplified39.1%
if -2.45e16 < b < -2.2999999999999998e-31 or -1.99999999999999989e-157 < b < 1.1100000000000001e-203 or 1.22000000000000001e-77 < b < 206Initial program 76.3%
cancel-sign-sub76.3%
cancel-sign-sub-inv76.3%
*-commutative76.3%
*-commutative76.3%
remove-double-neg76.3%
*-commutative76.3%
*-commutative76.3%
Simplified76.3%
Taylor expanded in a around inf 58.5%
distribute-lft-out--58.5%
distribute-lft-out--58.5%
sub-neg58.5%
mul-1-neg58.5%
remove-double-neg58.5%
+-commutative58.5%
mul-1-neg58.5%
unsub-neg58.5%
*-commutative58.5%
Simplified58.5%
Taylor expanded in b around 0 49.6%
neg-mul-149.6%
distribute-lft-neg-in49.6%
*-commutative49.6%
Simplified49.6%
if -2.2999999999999998e-31 < b < -1.99999999999999989e-157Initial program 69.5%
cancel-sign-sub69.5%
cancel-sign-sub-inv69.5%
*-commutative69.5%
*-commutative69.5%
remove-double-neg69.5%
*-commutative69.5%
*-commutative69.5%
Simplified69.5%
Taylor expanded in y around inf 62.5%
+-commutative62.5%
mul-1-neg62.5%
unsub-neg62.5%
Simplified62.5%
Taylor expanded in z around inf 45.5%
if 1.1100000000000001e-203 < b < 1.22000000000000001e-77Initial program 59.1%
cancel-sign-sub59.1%
cancel-sign-sub-inv59.1%
*-commutative59.1%
*-commutative59.1%
remove-double-neg59.1%
*-commutative59.1%
*-commutative59.1%
Simplified59.1%
Taylor expanded in y around inf 53.3%
+-commutative53.3%
mul-1-neg53.3%
unsub-neg53.3%
Simplified53.3%
Taylor expanded in z around 0 31.2%
mul-1-neg31.2%
*-commutative31.2%
distribute-lft-neg-in31.2%
distribute-lft-neg-in31.2%
*-commutative31.2%
associate-*l*34.1%
distribute-lft-neg-in34.1%
distribute-rgt-neg-in34.1%
Simplified34.1%
if 206 < b Initial program 80.2%
cancel-sign-sub80.2%
cancel-sign-sub-inv80.2%
*-commutative80.2%
*-commutative80.2%
remove-double-neg80.2%
*-commutative80.2%
*-commutative80.2%
Simplified80.2%
Taylor expanded in b around inf 67.7%
Taylor expanded in a around inf 51.2%
Final simplification45.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= j -0.0215)
(+ t_1 (* b (* a i)))
(if (<= j -3.6e-245)
(* x (- (* y z) (* t a)))
(if (<= j 2.5e-199)
(* b (- (* a i) (* z c)))
(if (<= j 5.8e+140) (* y (- (* x z) (* 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 = j * ((t * c) - (y * i));
double tmp;
if (j <= -0.0215) {
tmp = t_1 + (b * (a * i));
} else if (j <= -3.6e-245) {
tmp = x * ((y * z) - (t * a));
} else if (j <= 2.5e-199) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 5.8e+140) {
tmp = y * ((x * z) - (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 = j * ((t * c) - (y * i))
if (j <= (-0.0215d0)) then
tmp = t_1 + (b * (a * i))
else if (j <= (-3.6d-245)) then
tmp = x * ((y * z) - (t * a))
else if (j <= 2.5d-199) then
tmp = b * ((a * i) - (z * c))
else if (j <= 5.8d+140) then
tmp = y * ((x * z) - (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 = j * ((t * c) - (y * i));
double tmp;
if (j <= -0.0215) {
tmp = t_1 + (b * (a * i));
} else if (j <= -3.6e-245) {
tmp = x * ((y * z) - (t * a));
} else if (j <= 2.5e-199) {
tmp = b * ((a * i) - (z * c));
} else if (j <= 5.8e+140) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) tmp = 0 if j <= -0.0215: tmp = t_1 + (b * (a * i)) elif j <= -3.6e-245: tmp = x * ((y * z) - (t * a)) elif j <= 2.5e-199: tmp = b * ((a * i) - (z * c)) elif j <= 5.8e+140: tmp = y * ((x * z) - (i * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -0.0215) tmp = Float64(t_1 + Float64(b * Float64(a * i))); elseif (j <= -3.6e-245) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (j <= 2.5e-199) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (j <= 5.8e+140) tmp = Float64(y * Float64(Float64(x * z) - 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 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -0.0215) tmp = t_1 + (b * (a * i)); elseif (j <= -3.6e-245) tmp = x * ((y * z) - (t * a)); elseif (j <= 2.5e-199) tmp = b * ((a * i) - (z * c)); elseif (j <= 5.8e+140) tmp = y * ((x * z) - (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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -0.0215], N[(t$95$1 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -3.6e-245], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.5e-199], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 5.8e+140], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -0.0215:\\
\;\;\;\;t_1 + b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;j \leq -3.6 \cdot 10^{-245}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;j \leq 2.5 \cdot 10^{-199}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 5.8 \cdot 10^{+140}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if j < -0.021499999999999998Initial program 75.4%
cancel-sign-sub75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
*-commutative75.4%
remove-double-neg75.4%
*-commutative75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in i around inf 72.6%
associate-*r*74.3%
*-commutative74.3%
Simplified74.3%
if -0.021499999999999998 < j < -3.59999999999999999e-245Initial program 69.7%
+-commutative69.7%
fma-def69.7%
*-commutative69.7%
*-commutative69.7%
*-commutative69.7%
*-commutative69.7%
Simplified69.7%
Taylor expanded in j around 0 76.6%
Taylor expanded in x around inf 65.1%
if -3.59999999999999999e-245 < j < 2.4999999999999998e-199Initial program 75.4%
cancel-sign-sub75.4%
cancel-sign-sub-inv75.4%
*-commutative75.4%
*-commutative75.4%
remove-double-neg75.4%
*-commutative75.4%
*-commutative75.4%
Simplified75.4%
Taylor expanded in b around inf 55.7%
if 2.4999999999999998e-199 < j < 5.7999999999999998e140Initial program 71.1%
cancel-sign-sub71.1%
cancel-sign-sub-inv71.1%
*-commutative71.1%
*-commutative71.1%
remove-double-neg71.1%
*-commutative71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in y around inf 59.7%
+-commutative59.7%
mul-1-neg59.7%
unsub-neg59.7%
Simplified59.7%
if 5.7999999999999998e140 < j Initial program 84.0%
cancel-sign-sub84.0%
cancel-sign-sub-inv84.0%
*-commutative84.0%
*-commutative84.0%
remove-double-neg84.0%
*-commutative84.0%
*-commutative84.0%
Simplified84.0%
Taylor expanded in b around 0 73.1%
Taylor expanded in j around inf 72.2%
Final simplification65.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))) (t_2 (* b (* a i))))
(if (<= i -1.66e+106)
t_2
(if (<= i -3.8e-121)
(* z (* x y))
(if (<= i 1.4e-266)
t_1
(if (<= i 6.2e-47) (* y (* x z)) (if (<= i 1.32e+107) 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 * (x * t);
double t_2 = b * (a * i);
double tmp;
if (i <= -1.66e+106) {
tmp = t_2;
} else if (i <= -3.8e-121) {
tmp = z * (x * y);
} else if (i <= 1.4e-266) {
tmp = t_1;
} else if (i <= 6.2e-47) {
tmp = y * (x * z);
} else if (i <= 1.32e+107) {
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 * (x * t)
t_2 = b * (a * i)
if (i <= (-1.66d+106)) then
tmp = t_2
else if (i <= (-3.8d-121)) then
tmp = z * (x * y)
else if (i <= 1.4d-266) then
tmp = t_1
else if (i <= 6.2d-47) then
tmp = y * (x * z)
else if (i <= 1.32d+107) 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 * (x * t);
double t_2 = b * (a * i);
double tmp;
if (i <= -1.66e+106) {
tmp = t_2;
} else if (i <= -3.8e-121) {
tmp = z * (x * y);
} else if (i <= 1.4e-266) {
tmp = t_1;
} else if (i <= 6.2e-47) {
tmp = y * (x * z);
} else if (i <= 1.32e+107) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) t_2 = b * (a * i) tmp = 0 if i <= -1.66e+106: tmp = t_2 elif i <= -3.8e-121: tmp = z * (x * y) elif i <= 1.4e-266: tmp = t_1 elif i <= 6.2e-47: tmp = y * (x * z) elif i <= 1.32e+107: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) t_2 = Float64(b * Float64(a * i)) tmp = 0.0 if (i <= -1.66e+106) tmp = t_2; elseif (i <= -3.8e-121) tmp = Float64(z * Float64(x * y)); elseif (i <= 1.4e-266) tmp = t_1; elseif (i <= 6.2e-47) tmp = Float64(y * Float64(x * z)); elseif (i <= 1.32e+107) 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 * (x * t); t_2 = b * (a * i); tmp = 0.0; if (i <= -1.66e+106) tmp = t_2; elseif (i <= -3.8e-121) tmp = z * (x * y); elseif (i <= 1.4e-266) tmp = t_1; elseif (i <= 6.2e-47) tmp = y * (x * z); elseif (i <= 1.32e+107) 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[(x * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.66e+106], t$95$2, If[LessEqual[i, -3.8e-121], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.4e-266], t$95$1, If[LessEqual[i, 6.2e-47], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.32e+107], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
t_2 := b \cdot \left(a \cdot i\right)\\
\mathbf{if}\;i \leq -1.66 \cdot 10^{+106}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;i \leq -3.8 \cdot 10^{-121}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;i \leq 1.4 \cdot 10^{-266}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;i \leq 6.2 \cdot 10^{-47}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;i \leq 1.32 \cdot 10^{+107}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if i < -1.66e106 or 1.32000000000000003e107 < i Initial program 65.7%
cancel-sign-sub65.7%
cancel-sign-sub-inv65.7%
*-commutative65.7%
*-commutative65.7%
remove-double-neg65.7%
*-commutative65.7%
*-commutative65.7%
Simplified65.7%
Taylor expanded in b around inf 54.8%
Taylor expanded in a around inf 45.2%
if -1.66e106 < i < -3.8000000000000001e-121Initial program 71.6%
cancel-sign-sub71.6%
cancel-sign-sub-inv71.6%
*-commutative71.6%
*-commutative71.6%
remove-double-neg71.6%
*-commutative71.6%
*-commutative71.6%
Simplified71.6%
Taylor expanded in b around 0 65.0%
Taylor expanded in c around inf 53.5%
associate-*r*53.4%
Simplified53.4%
Taylor expanded in t around 0 37.1%
associate-*r*34.9%
*-commutative34.9%
associate-*l*37.2%
Simplified37.2%
if -3.8000000000000001e-121 < i < 1.4e-266 or 6.1999999999999996e-47 < i < 1.32000000000000003e107Initial program 80.6%
cancel-sign-sub80.6%
cancel-sign-sub-inv80.6%
*-commutative80.6%
*-commutative80.6%
remove-double-neg80.6%
*-commutative80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in a around inf 56.3%
distribute-lft-out--56.3%
distribute-lft-out--56.3%
sub-neg56.3%
mul-1-neg56.3%
remove-double-neg56.3%
+-commutative56.3%
mul-1-neg56.3%
unsub-neg56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in b around 0 43.9%
neg-mul-143.9%
distribute-lft-neg-in43.9%
*-commutative43.9%
Simplified43.9%
if 1.4e-266 < i < 6.1999999999999996e-47Initial program 84.1%
cancel-sign-sub84.1%
cancel-sign-sub-inv84.1%
*-commutative84.1%
*-commutative84.1%
remove-double-neg84.1%
*-commutative84.1%
*-commutative84.1%
Simplified84.1%
Taylor expanded in y around inf 45.6%
+-commutative45.6%
mul-1-neg45.6%
unsub-neg45.6%
Simplified45.6%
Taylor expanded in z around inf 39.6%
Final simplification42.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= z -7.6e+116) (not (<= z 8.8e+184))) (* y (* x z)) (* a (- (* b i) (* x t)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -7.6e+116) || !(z <= 8.8e+184)) {
tmp = y * (x * z);
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((z <= (-7.6d+116)) .or. (.not. (z <= 8.8d+184))) then
tmp = y * (x * z)
else
tmp = a * ((b * i) - (x * t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -7.6e+116) || !(z <= 8.8e+184)) {
tmp = y * (x * z);
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (z <= -7.6e+116) or not (z <= 8.8e+184): tmp = y * (x * z) else: tmp = a * ((b * i) - (x * t)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((z <= -7.6e+116) || !(z <= 8.8e+184)) tmp = Float64(y * Float64(x * z)); else tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((z <= -7.6e+116) || ~((z <= 8.8e+184))) tmp = y * (x * z); else tmp = a * ((b * i) - (x * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[z, -7.6e+116], N[Not[LessEqual[z, 8.8e+184]], $MachinePrecision]], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.6 \cdot 10^{+116} \lor \neg \left(z \leq 8.8 \cdot 10^{+184}\right):\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\end{array}
\end{array}
if z < -7.5999999999999998e116 or 8.8e184 < z Initial program 61.5%
cancel-sign-sub61.5%
cancel-sign-sub-inv61.5%
*-commutative61.5%
*-commutative61.5%
remove-double-neg61.5%
*-commutative61.5%
*-commutative61.5%
Simplified61.5%
Taylor expanded in y around inf 59.6%
+-commutative59.6%
mul-1-neg59.6%
unsub-neg59.6%
Simplified59.6%
Taylor expanded in z around inf 52.4%
if -7.5999999999999998e116 < z < 8.8e184Initial program 80.3%
cancel-sign-sub80.3%
cancel-sign-sub-inv80.3%
*-commutative80.3%
*-commutative80.3%
remove-double-neg80.3%
*-commutative80.3%
*-commutative80.3%
Simplified80.3%
Taylor expanded in a around inf 51.5%
distribute-lft-out--51.5%
distribute-lft-out--51.5%
sub-neg51.5%
mul-1-neg51.5%
remove-double-neg51.5%
+-commutative51.5%
mul-1-neg51.5%
unsub-neg51.5%
*-commutative51.5%
Simplified51.5%
Final simplification51.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= t -1e-17) (not (<= t 7400000000000.0))) (* c (* t j)) (* a (* b i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((t <= -1e-17) || !(t <= 7400000000000.0)) {
tmp = c * (t * j);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((t <= (-1d-17)) .or. (.not. (t <= 7400000000000.0d0))) then
tmp = c * (t * j)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((t <= -1e-17) || !(t <= 7400000000000.0)) {
tmp = c * (t * j);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (t <= -1e-17) or not (t <= 7400000000000.0): tmp = c * (t * j) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((t <= -1e-17) || !(t <= 7400000000000.0)) tmp = Float64(c * Float64(t * j)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((t <= -1e-17) || ~((t <= 7400000000000.0))) tmp = c * (t * j); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[t, -1e-17], N[Not[LessEqual[t, 7400000000000.0]], $MachinePrecision]], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1 \cdot 10^{-17} \lor \neg \left(t \leq 7400000000000\right):\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if t < -1.00000000000000007e-17 or 7.4e12 < t Initial program 69.2%
cancel-sign-sub69.2%
cancel-sign-sub-inv69.2%
*-commutative69.2%
*-commutative69.2%
remove-double-neg69.2%
*-commutative69.2%
*-commutative69.2%
Simplified69.2%
Taylor expanded in b around 0 68.1%
Taylor expanded in j around inf 41.1%
Taylor expanded in c around inf 31.0%
if -1.00000000000000007e-17 < t < 7.4e12Initial program 78.9%
+-commutative78.9%
fma-def79.6%
*-commutative79.6%
*-commutative79.6%
*-commutative79.6%
*-commutative79.6%
Simplified79.6%
Taylor expanded in j around 0 69.8%
Taylor expanded in i around inf 29.2%
Final simplification30.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= x -2.55e+104) (not (<= x 1.7e+23))) (* y (* x z)) (* b (* a i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((x <= -2.55e+104) || !(x <= 1.7e+23)) {
tmp = y * (x * z);
} else {
tmp = b * (a * 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 ((x <= (-2.55d+104)) .or. (.not. (x <= 1.7d+23))) then
tmp = y * (x * z)
else
tmp = b * (a * 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 ((x <= -2.55e+104) || !(x <= 1.7e+23)) {
tmp = y * (x * z);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (x <= -2.55e+104) or not (x <= 1.7e+23): tmp = y * (x * z) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((x <= -2.55e+104) || !(x <= 1.7e+23)) tmp = Float64(y * Float64(x * z)); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((x <= -2.55e+104) || ~((x <= 1.7e+23))) tmp = y * (x * z); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[x, -2.55e+104], N[Not[LessEqual[x, 1.7e+23]], $MachinePrecision]], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -2.55 \cdot 10^{+104} \lor \neg \left(x \leq 1.7 \cdot 10^{+23}\right):\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if x < -2.5500000000000001e104 or 1.69999999999999996e23 < x Initial program 68.3%
cancel-sign-sub68.3%
cancel-sign-sub-inv68.3%
*-commutative68.3%
*-commutative68.3%
remove-double-neg68.3%
*-commutative68.3%
*-commutative68.3%
Simplified68.3%
Taylor expanded in y around inf 51.6%
+-commutative51.6%
mul-1-neg51.6%
unsub-neg51.6%
Simplified51.6%
Taylor expanded in z around inf 46.8%
if -2.5500000000000001e104 < x < 1.69999999999999996e23Initial program 78.6%
cancel-sign-sub78.6%
cancel-sign-sub-inv78.6%
*-commutative78.6%
*-commutative78.6%
remove-double-neg78.6%
*-commutative78.6%
*-commutative78.6%
Simplified78.6%
Taylor expanded in b around inf 47.9%
Taylor expanded in a around inf 30.4%
Final simplification37.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -7.5e+155) (* a (* b i)) (if (<= b 2.4e+77) (* x (* y z)) (* i (* a b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -7.5e+155) {
tmp = a * (b * i);
} else if (b <= 2.4e+77) {
tmp = x * (y * z);
} else {
tmp = i * (a * 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 (b <= (-7.5d+155)) then
tmp = a * (b * i)
else if (b <= 2.4d+77) then
tmp = x * (y * z)
else
tmp = i * (a * 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 (b <= -7.5e+155) {
tmp = a * (b * i);
} else if (b <= 2.4e+77) {
tmp = x * (y * z);
} else {
tmp = i * (a * b);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -7.5e+155: tmp = a * (b * i) elif b <= 2.4e+77: tmp = x * (y * z) else: tmp = i * (a * b) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -7.5e+155) tmp = Float64(a * Float64(b * i)); elseif (b <= 2.4e+77) tmp = Float64(x * Float64(y * z)); else tmp = Float64(i * Float64(a * b)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -7.5e+155) tmp = a * (b * i); elseif (b <= 2.4e+77) tmp = x * (y * z); else tmp = i * (a * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -7.5e+155], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.4e+77], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7.5 \cdot 10^{+155}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;b \leq 2.4 \cdot 10^{+77}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if b < -7.4999999999999999e155Initial program 76.9%
+-commutative76.9%
fma-def76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in j around 0 80.4%
Taylor expanded in i around inf 47.8%
if -7.4999999999999999e155 < b < 2.3999999999999999e77Initial program 71.3%
cancel-sign-sub71.3%
cancel-sign-sub-inv71.3%
*-commutative71.3%
*-commutative71.3%
remove-double-neg71.3%
*-commutative71.3%
*-commutative71.3%
Simplified71.3%
Taylor expanded in b around 0 65.7%
Taylor expanded in c around inf 57.2%
associate-*r*57.2%
Simplified57.2%
Taylor expanded in t around 0 29.9%
*-commutative29.9%
*-commutative29.9%
associate-*l*29.4%
Simplified29.4%
if 2.3999999999999999e77 < b Initial program 85.9%
cancel-sign-sub85.9%
cancel-sign-sub-inv85.9%
*-commutative85.9%
*-commutative85.9%
remove-double-neg85.9%
*-commutative85.9%
*-commutative85.9%
Simplified85.9%
Taylor expanded in a around inf 55.2%
distribute-lft-out--55.2%
distribute-lft-out--55.2%
sub-neg55.2%
mul-1-neg55.2%
remove-double-neg55.2%
+-commutative55.2%
mul-1-neg55.2%
unsub-neg55.2%
*-commutative55.2%
Simplified55.2%
Taylor expanded in b around inf 57.3%
Final simplification36.2%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -1.3e+154) (* a (* b i)) (if (<= b 7.8e+79) (* y (* x z)) (* i (* a b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -1.3e+154) {
tmp = a * (b * i);
} else if (b <= 7.8e+79) {
tmp = y * (x * z);
} else {
tmp = i * (a * 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 (b <= (-1.3d+154)) then
tmp = a * (b * i)
else if (b <= 7.8d+79) then
tmp = y * (x * z)
else
tmp = i * (a * 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 (b <= -1.3e+154) {
tmp = a * (b * i);
} else if (b <= 7.8e+79) {
tmp = y * (x * z);
} else {
tmp = i * (a * b);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -1.3e+154: tmp = a * (b * i) elif b <= 7.8e+79: tmp = y * (x * z) else: tmp = i * (a * b) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -1.3e+154) tmp = Float64(a * Float64(b * i)); elseif (b <= 7.8e+79) tmp = Float64(y * Float64(x * z)); else tmp = Float64(i * Float64(a * b)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -1.3e+154) tmp = a * (b * i); elseif (b <= 7.8e+79) tmp = y * (x * z); else tmp = i * (a * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -1.3e+154], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7.8e+79], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.3 \cdot 10^{+154}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;b \leq 7.8 \cdot 10^{+79}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if b < -1.29999999999999994e154Initial program 76.9%
+-commutative76.9%
fma-def76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in j around 0 80.4%
Taylor expanded in i around inf 47.8%
if -1.29999999999999994e154 < b < 7.7999999999999994e79Initial program 71.3%
cancel-sign-sub71.3%
cancel-sign-sub-inv71.3%
*-commutative71.3%
*-commutative71.3%
remove-double-neg71.3%
*-commutative71.3%
*-commutative71.3%
Simplified71.3%
Taylor expanded in y around inf 46.6%
+-commutative46.6%
mul-1-neg46.6%
unsub-neg46.6%
Simplified46.6%
Taylor expanded in z around inf 29.9%
if 7.7999999999999994e79 < b Initial program 85.9%
cancel-sign-sub85.9%
cancel-sign-sub-inv85.9%
*-commutative85.9%
*-commutative85.9%
remove-double-neg85.9%
*-commutative85.9%
*-commutative85.9%
Simplified85.9%
Taylor expanded in a around inf 55.2%
distribute-lft-out--55.2%
distribute-lft-out--55.2%
sub-neg55.2%
mul-1-neg55.2%
remove-double-neg55.2%
+-commutative55.2%
mul-1-neg55.2%
unsub-neg55.2%
*-commutative55.2%
Simplified55.2%
Taylor expanded in b around inf 57.3%
Final simplification36.6%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* b i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = a * (b * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
def code(x, y, z, t, a, b, c, i, j): return a * (b * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(b * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (b * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(b \cdot i\right)
\end{array}
Initial program 74.4%
+-commutative74.4%
fma-def74.8%
*-commutative74.8%
*-commutative74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in j around 0 65.1%
Taylor expanded in i around inf 22.8%
Final simplification22.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2023242
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:herbie-target
(if (< t -8.120978919195912e-33) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -4.712553818218485e-169) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (if (< t -7.633533346031584e-308) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 1.0535888557455487e-139) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))