
(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 25 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 (- (* t c) (* y i))))
(if (<= (+ (+ (* x (- (* y z) (* t a))) t_1) (* j t_2)) INFINITY)
(fma j t_2 (+ (* x (fma y z (* t (- a)))) t_1))
(* c (- (* t j) (* z b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = (t * c) - (y * i);
double tmp;
if ((((x * ((y * z) - (t * a))) + t_1) + (j * t_2)) <= ((double) INFINITY)) {
tmp = fma(j, t_2, ((x * fma(y, z, (t * -a))) + t_1));
} else {
tmp = c * ((t * j) - (z * b));
}
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(t * c) - Float64(y * i)) tmp = 0.0 if (Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1) + Float64(j * t_2)) <= Inf) tmp = fma(j, t_2, Float64(Float64(x * fma(y, z, Float64(t * Float64(-a)))) + t_1)); else tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); 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[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + N[(j * t$95$2), $MachinePrecision]), $MachinePrecision], Infinity], N[(j * t$95$2 + N[(N[(x * N[(y * z + N[(t * (-a)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := t \cdot c - y \cdot i\\
\mathbf{if}\;\left(x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\right) + j \cdot t\_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(j, t\_2, x \cdot \mathsf{fma}\left(y, z, t \cdot \left(-a\right)\right) + t\_1\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\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 91.6%
+-commutative91.6%
fma-define91.6%
*-commutative91.6%
*-commutative91.6%
cancel-sign-sub-inv91.6%
cancel-sign-sub91.6%
sub-neg91.6%
sub-neg91.6%
*-commutative91.6%
fma-neg91.6%
*-commutative91.6%
distribute-rgt-neg-out91.6%
remove-double-neg91.6%
*-commutative91.6%
*-commutative91.6%
Simplified91.6%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in c around inf 61.8%
*-commutative61.8%
*-commutative61.8%
Simplified61.8%
Final simplification87.0%
(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 (* c (- (* t j) (* z b))))))
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 = c * ((t * j) - (z * b));
}
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 = c * ((t * j) - (z * b));
}
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 = c * ((t * j) - (z * b)) 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(c * Float64(Float64(t * j) - Float64(z * b))); 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 = c * ((t * j) - (z * b)); 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[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $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}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\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 91.6%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in c around inf 61.8%
*-commutative61.8%
*-commutative61.8%
Simplified61.8%
Final simplification87.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* y z) (* t a)))
(t_2 (* x (+ t_1 (/ (* a (* b i)) x))))
(t_3 (* j (- (* t c) (* y i)))))
(if (<= j -6.7e+16)
t_3
(if (<= j -53.0)
t_2
(if (<= j -9.5e-20)
t_3
(if (<= j -7e-120)
(- (* x t_1) (* i (* y j)))
(if (<= j 3e-278)
(+ (* x (* y z)) (* b (- (* a i) (* z c))))
(if (<= j 2.75e+63) t_2 t_3))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (y * z) - (t * a);
double t_2 = x * (t_1 + ((a * (b * i)) / x));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -6.7e+16) {
tmp = t_3;
} else if (j <= -53.0) {
tmp = t_2;
} else if (j <= -9.5e-20) {
tmp = t_3;
} else if (j <= -7e-120) {
tmp = (x * t_1) - (i * (y * j));
} else if (j <= 3e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 2.75e+63) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = (y * z) - (t * a)
t_2 = x * (t_1 + ((a * (b * i)) / x))
t_3 = j * ((t * c) - (y * i))
if (j <= (-6.7d+16)) then
tmp = t_3
else if (j <= (-53.0d0)) then
tmp = t_2
else if (j <= (-9.5d-20)) then
tmp = t_3
else if (j <= (-7d-120)) then
tmp = (x * t_1) - (i * (y * j))
else if (j <= 3d-278) then
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
else if (j <= 2.75d+63) then
tmp = t_2
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (y * z) - (t * a);
double t_2 = x * (t_1 + ((a * (b * i)) / x));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -6.7e+16) {
tmp = t_3;
} else if (j <= -53.0) {
tmp = t_2;
} else if (j <= -9.5e-20) {
tmp = t_3;
} else if (j <= -7e-120) {
tmp = (x * t_1) - (i * (y * j));
} else if (j <= 3e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 2.75e+63) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (y * z) - (t * a) t_2 = x * (t_1 + ((a * (b * i)) / x)) t_3 = j * ((t * c) - (y * i)) tmp = 0 if j <= -6.7e+16: tmp = t_3 elif j <= -53.0: tmp = t_2 elif j <= -9.5e-20: tmp = t_3 elif j <= -7e-120: tmp = (x * t_1) - (i * (y * j)) elif j <= 3e-278: tmp = (x * (y * z)) + (b * ((a * i) - (z * c))) elif j <= 2.75e+63: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(y * z) - Float64(t * a)) t_2 = Float64(x * Float64(t_1 + Float64(Float64(a * Float64(b * i)) / x))) t_3 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -6.7e+16) tmp = t_3; elseif (j <= -53.0) tmp = t_2; elseif (j <= -9.5e-20) tmp = t_3; elseif (j <= -7e-120) tmp = Float64(Float64(x * t_1) - Float64(i * Float64(y * j))); elseif (j <= 3e-278) tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (j <= 2.75e+63) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (y * z) - (t * a); t_2 = x * (t_1 + ((a * (b * i)) / x)); t_3 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -6.7e+16) tmp = t_3; elseif (j <= -53.0) tmp = t_2; elseif (j <= -9.5e-20) tmp = t_3; elseif (j <= -7e-120) tmp = (x * t_1) - (i * (y * j)); elseif (j <= 3e-278) tmp = (x * (y * z)) + (b * ((a * i) - (z * c))); elseif (j <= 2.75e+63) tmp = t_2; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(t$95$1 + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -6.7e+16], t$95$3, If[LessEqual[j, -53.0], t$95$2, If[LessEqual[j, -9.5e-20], t$95$3, If[LessEqual[j, -7e-120], N[(N[(x * t$95$1), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 3e-278], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.75e+63], t$95$2, t$95$3]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot z - t \cdot a\\
t_2 := x \cdot \left(t\_1 + \frac{a \cdot \left(b \cdot i\right)}{x}\right)\\
t_3 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -6.7 \cdot 10^{+16}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;j \leq -53:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -9.5 \cdot 10^{-20}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;j \leq -7 \cdot 10^{-120}:\\
\;\;\;\;x \cdot t\_1 - i \cdot \left(y \cdot j\right)\\
\mathbf{elif}\;j \leq 3 \cdot 10^{-278}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 2.75 \cdot 10^{+63}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if j < -6.7e16 or -53 < j < -9.5e-20 or 2.75000000000000002e63 < j Initial program 78.6%
Taylor expanded in j around inf 67.0%
if -6.7e16 < j < -53 or 3e-278 < j < 2.75000000000000002e63Initial program 73.9%
Taylor expanded in x around inf 72.9%
associate--r+72.9%
sub-neg72.9%
mul-1-neg72.9%
+-commutative72.9%
associate-+r+72.9%
associate-+r-72.9%
+-commutative72.9%
div-sub74.2%
Simplified74.2%
Taylor expanded in a around inf 72.5%
if -9.5e-20 < j < -7e-120Initial program 75.4%
Taylor expanded in b around 0 73.5%
Taylor expanded in c around 0 70.5%
+-commutative70.5%
sub-neg70.5%
*-commutative70.5%
sub-neg70.5%
mul-1-neg70.5%
unsub-neg70.5%
Simplified70.5%
if -7e-120 < j < 3e-278Initial program 82.7%
Taylor expanded in t around 0 82.7%
*-commutative82.7%
associate-*r*80.3%
associate-*r*80.3%
associate-*r*80.3%
distribute-rgt-in80.3%
+-commutative80.3%
mul-1-neg80.3%
unsub-neg80.3%
*-commutative80.3%
Simplified80.3%
Taylor expanded in x around inf 78.0%
Final simplification70.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* y z) (* t a)))
(t_2 (* x (+ t_1 (/ (* a (* b i)) x))))
(t_3 (* j (- (* t c) (* y i)))))
(if (<= j -1.16e+17)
t_3
(if (<= j -33.0)
t_2
(if (<= j -8.5e-20)
t_3
(if (<= j -1.7e-125)
(- (* x t_1) (* i (* y j)))
(if (<= j 1.5e-278)
(+ (* x (* y z)) (* b (- (* a i) (* z c))))
(if (<= j 1e-37)
t_2
(- (* j (* c (- t (* i (/ y c))))) (* a (* x t)))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (y * z) - (t * a);
double t_2 = x * (t_1 + ((a * (b * i)) / x));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -1.16e+17) {
tmp = t_3;
} else if (j <= -33.0) {
tmp = t_2;
} else if (j <= -8.5e-20) {
tmp = t_3;
} else if (j <= -1.7e-125) {
tmp = (x * t_1) - (i * (y * j));
} else if (j <= 1.5e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 1e-37) {
tmp = t_2;
} else {
tmp = (j * (c * (t - (i * (y / c))))) - (a * (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) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = (y * z) - (t * a)
t_2 = x * (t_1 + ((a * (b * i)) / x))
t_3 = j * ((t * c) - (y * i))
if (j <= (-1.16d+17)) then
tmp = t_3
else if (j <= (-33.0d0)) then
tmp = t_2
else if (j <= (-8.5d-20)) then
tmp = t_3
else if (j <= (-1.7d-125)) then
tmp = (x * t_1) - (i * (y * j))
else if (j <= 1.5d-278) then
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
else if (j <= 1d-37) then
tmp = t_2
else
tmp = (j * (c * (t - (i * (y / c))))) - (a * (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 t_1 = (y * z) - (t * a);
double t_2 = x * (t_1 + ((a * (b * i)) / x));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (j <= -1.16e+17) {
tmp = t_3;
} else if (j <= -33.0) {
tmp = t_2;
} else if (j <= -8.5e-20) {
tmp = t_3;
} else if (j <= -1.7e-125) {
tmp = (x * t_1) - (i * (y * j));
} else if (j <= 1.5e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 1e-37) {
tmp = t_2;
} else {
tmp = (j * (c * (t - (i * (y / c))))) - (a * (x * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (y * z) - (t * a) t_2 = x * (t_1 + ((a * (b * i)) / x)) t_3 = j * ((t * c) - (y * i)) tmp = 0 if j <= -1.16e+17: tmp = t_3 elif j <= -33.0: tmp = t_2 elif j <= -8.5e-20: tmp = t_3 elif j <= -1.7e-125: tmp = (x * t_1) - (i * (y * j)) elif j <= 1.5e-278: tmp = (x * (y * z)) + (b * ((a * i) - (z * c))) elif j <= 1e-37: tmp = t_2 else: tmp = (j * (c * (t - (i * (y / c))))) - (a * (x * t)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(y * z) - Float64(t * a)) t_2 = Float64(x * Float64(t_1 + Float64(Float64(a * Float64(b * i)) / x))) t_3 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -1.16e+17) tmp = t_3; elseif (j <= -33.0) tmp = t_2; elseif (j <= -8.5e-20) tmp = t_3; elseif (j <= -1.7e-125) tmp = Float64(Float64(x * t_1) - Float64(i * Float64(y * j))); elseif (j <= 1.5e-278) tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (j <= 1e-37) tmp = t_2; else tmp = Float64(Float64(j * Float64(c * Float64(t - Float64(i * Float64(y / c))))) - Float64(a * Float64(x * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (y * z) - (t * a); t_2 = x * (t_1 + ((a * (b * i)) / x)); t_3 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -1.16e+17) tmp = t_3; elseif (j <= -33.0) tmp = t_2; elseif (j <= -8.5e-20) tmp = t_3; elseif (j <= -1.7e-125) tmp = (x * t_1) - (i * (y * j)); elseif (j <= 1.5e-278) tmp = (x * (y * z)) + (b * ((a * i) - (z * c))); elseif (j <= 1e-37) tmp = t_2; else tmp = (j * (c * (t - (i * (y / c))))) - (a * (x * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(t$95$1 + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.16e+17], t$95$3, If[LessEqual[j, -33.0], t$95$2, If[LessEqual[j, -8.5e-20], t$95$3, If[LessEqual[j, -1.7e-125], N[(N[(x * t$95$1), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.5e-278], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1e-37], t$95$2, N[(N[(j * N[(c * N[(t - N[(i * N[(y / c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot z - t \cdot a\\
t_2 := x \cdot \left(t\_1 + \frac{a \cdot \left(b \cdot i\right)}{x}\right)\\
t_3 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -1.16 \cdot 10^{+17}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;j \leq -33:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -8.5 \cdot 10^{-20}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;j \leq -1.7 \cdot 10^{-125}:\\
\;\;\;\;x \cdot t\_1 - i \cdot \left(y \cdot j\right)\\
\mathbf{elif}\;j \leq 1.5 \cdot 10^{-278}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 10^{-37}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(c \cdot \left(t - i \cdot \frac{y}{c}\right)\right) - a \cdot \left(x \cdot t\right)\\
\end{array}
\end{array}
if j < -1.16e17 or -33 < j < -8.5000000000000005e-20Initial program 84.9%
Taylor expanded in j around inf 71.9%
if -1.16e17 < j < -33 or 1.5e-278 < j < 1.00000000000000007e-37Initial program 65.5%
Taylor expanded in x around inf 67.7%
associate--r+67.7%
sub-neg67.7%
mul-1-neg67.7%
+-commutative67.7%
associate-+r+67.7%
associate-+r-67.7%
+-commutative67.7%
div-sub67.7%
Simplified67.7%
Taylor expanded in a around inf 74.5%
if -8.5000000000000005e-20 < j < -1.69999999999999988e-125Initial program 75.4%
Taylor expanded in b around 0 73.5%
Taylor expanded in c around 0 70.5%
+-commutative70.5%
sub-neg70.5%
*-commutative70.5%
sub-neg70.5%
mul-1-neg70.5%
unsub-neg70.5%
Simplified70.5%
if -1.69999999999999988e-125 < j < 1.5e-278Initial program 82.7%
Taylor expanded in t around 0 82.7%
*-commutative82.7%
associate-*r*80.3%
associate-*r*80.3%
associate-*r*80.3%
distribute-rgt-in80.3%
+-commutative80.3%
mul-1-neg80.3%
unsub-neg80.3%
*-commutative80.3%
Simplified80.3%
Taylor expanded in x around inf 78.0%
if 1.00000000000000007e-37 < j Initial program 77.6%
Taylor expanded in b around 0 72.8%
Taylor expanded in c around inf 71.6%
mul-1-neg71.6%
unsub-neg71.6%
associate-/l*71.6%
Simplified71.6%
Taylor expanded in y around 0 66.6%
associate-*r*66.6%
mul-1-neg66.6%
Simplified66.6%
Final simplification71.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* z (- x (* i (/ j z)))))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -1.4e+54)
t_2
(if (<= t -8.8e-94)
t_1
(if (<= t 1.18e-178)
(+ (* x (* y z)) (* b (- (* a i) (* z c))))
(if (<= t 1.8e-77)
(* i (* y (- (* a (/ b y)) j)))
(if (or (<= t 2.12e-20) (not (<= t 6.6e+89))) t_2 t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = y * (z * (x - (i * (j / z))));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.4e+54) {
tmp = t_2;
} else if (t <= -8.8e-94) {
tmp = t_1;
} else if (t <= 1.18e-178) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (t <= 1.8e-77) {
tmp = i * (y * ((a * (b / y)) - j));
} else if ((t <= 2.12e-20) || !(t <= 6.6e+89)) {
tmp = t_2;
} 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) :: t_2
real(8) :: tmp
t_1 = y * (z * (x - (i * (j / z))))
t_2 = t * ((c * j) - (x * a))
if (t <= (-1.4d+54)) then
tmp = t_2
else if (t <= (-8.8d-94)) then
tmp = t_1
else if (t <= 1.18d-178) then
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
else if (t <= 1.8d-77) then
tmp = i * (y * ((a * (b / y)) - j))
else if ((t <= 2.12d-20) .or. (.not. (t <= 6.6d+89))) then
tmp = t_2
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = y * (z * (x - (i * (j / z))));
double t_2 = t * ((c * j) - (x * a));
double tmp;
if (t <= -1.4e+54) {
tmp = t_2;
} else if (t <= -8.8e-94) {
tmp = t_1;
} else if (t <= 1.18e-178) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (t <= 1.8e-77) {
tmp = i * (y * ((a * (b / y)) - j));
} else if ((t <= 2.12e-20) || !(t <= 6.6e+89)) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (z * (x - (i * (j / z)))) t_2 = t * ((c * j) - (x * a)) tmp = 0 if t <= -1.4e+54: tmp = t_2 elif t <= -8.8e-94: tmp = t_1 elif t <= 1.18e-178: tmp = (x * (y * z)) + (b * ((a * i) - (z * c))) elif t <= 1.8e-77: tmp = i * (y * ((a * (b / y)) - j)) elif (t <= 2.12e-20) or not (t <= 6.6e+89): tmp = t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(z * Float64(x - Float64(i * Float64(j / z))))) t_2 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -1.4e+54) tmp = t_2; elseif (t <= -8.8e-94) tmp = t_1; elseif (t <= 1.18e-178) tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (t <= 1.8e-77) tmp = Float64(i * Float64(y * Float64(Float64(a * Float64(b / y)) - j))); elseif ((t <= 2.12e-20) || !(t <= 6.6e+89)) tmp = t_2; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * (z * (x - (i * (j / z)))); t_2 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -1.4e+54) tmp = t_2; elseif (t <= -8.8e-94) tmp = t_1; elseif (t <= 1.18e-178) tmp = (x * (y * z)) + (b * ((a * i) - (z * c))); elseif (t <= 1.8e-77) tmp = i * (y * ((a * (b / y)) - j)); elseif ((t <= 2.12e-20) || ~((t <= 6.6e+89))) tmp = t_2; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(z * N[(x - N[(i * N[(j / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.4e+54], t$95$2, If[LessEqual[t, -8.8e-94], t$95$1, If[LessEqual[t, 1.18e-178], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.8e-77], N[(i * N[(y * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, 2.12e-20], N[Not[LessEqual[t, 6.6e+89]], $MachinePrecision]], t$95$2, t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(z \cdot \left(x - i \cdot \frac{j}{z}\right)\right)\\
t_2 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -1.4 \cdot 10^{+54}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -8.8 \cdot 10^{-94}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 1.18 \cdot 10^{-178}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;t \leq 1.8 \cdot 10^{-77}:\\
\;\;\;\;i \cdot \left(y \cdot \left(a \cdot \frac{b}{y} - j\right)\right)\\
\mathbf{elif}\;t \leq 2.12 \cdot 10^{-20} \lor \neg \left(t \leq 6.6 \cdot 10^{+89}\right):\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.40000000000000008e54 or 1.8e-77 < t < 2.12e-20 or 6.59999999999999948e89 < t Initial program 72.8%
Taylor expanded in t around inf 69.6%
+-commutative69.6%
mul-1-neg69.6%
unsub-neg69.6%
*-commutative69.6%
Simplified69.6%
if -1.40000000000000008e54 < t < -8.80000000000000004e-94 or 2.12e-20 < t < 6.59999999999999948e89Initial program 80.7%
Taylor expanded in y around inf 53.3%
+-commutative53.3%
mul-1-neg53.3%
unsub-neg53.3%
Simplified53.3%
Taylor expanded in z around inf 55.2%
mul-1-neg55.2%
unsub-neg55.2%
associate-/l*57.2%
Simplified57.2%
if -8.80000000000000004e-94 < t < 1.18000000000000006e-178Initial program 81.3%
Taylor expanded in t around 0 75.3%
*-commutative75.3%
associate-*r*73.0%
associate-*r*70.7%
associate-*r*70.7%
distribute-rgt-in72.0%
+-commutative72.0%
mul-1-neg72.0%
unsub-neg72.0%
*-commutative72.0%
Simplified72.0%
Taylor expanded in x around inf 69.3%
if 1.18000000000000006e-178 < t < 1.8e-77Initial program 82.1%
Taylor expanded in i around inf 76.2%
distribute-lft-out--76.2%
*-commutative76.2%
Simplified76.2%
Taylor expanded in y around inf 76.2%
mul-1-neg76.2%
unsub-neg76.2%
associate-/l*76.2%
Simplified76.2%
Final simplification67.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c))))
(t_2 (+ (* y (- (* x z) (* i j))) t_1)))
(if (<= b -3.15e+94)
t_2
(if (<= b -0.0042)
(+ (* t (- (* c j) (* x a))) t_1)
(if (<= b 2e-14)
(+ (* x (- (* y z) (* t a))) (* j (- (* t c) (* y i))))
(if (<= b 1.15e+122) (* x (+ (* y z) (- (/ t_1 x) (* t a)))) t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = (y * ((x * z) - (i * j))) + t_1;
double tmp;
if (b <= -3.15e+94) {
tmp = t_2;
} else if (b <= -0.0042) {
tmp = (t * ((c * j) - (x * a))) + t_1;
} else if (b <= 2e-14) {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
} else if (b <= 1.15e+122) {
tmp = x * ((y * z) + ((t_1 / x) - (t * a)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
t_2 = (y * ((x * z) - (i * j))) + t_1
if (b <= (-3.15d+94)) then
tmp = t_2
else if (b <= (-0.0042d0)) then
tmp = (t * ((c * j) - (x * a))) + t_1
else if (b <= 2d-14) then
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)))
else if (b <= 1.15d+122) then
tmp = x * ((y * z) + ((t_1 / x) - (t * a)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = (y * ((x * z) - (i * j))) + t_1;
double tmp;
if (b <= -3.15e+94) {
tmp = t_2;
} else if (b <= -0.0042) {
tmp = (t * ((c * j) - (x * a))) + t_1;
} else if (b <= 2e-14) {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
} else if (b <= 1.15e+122) {
tmp = x * ((y * z) + ((t_1 / x) - (t * a)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) t_2 = (y * ((x * z) - (i * j))) + t_1 tmp = 0 if b <= -3.15e+94: tmp = t_2 elif b <= -0.0042: tmp = (t * ((c * j) - (x * a))) + t_1 elif b <= 2e-14: tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))) elif b <= 1.15e+122: tmp = x * ((y * z) + ((t_1 / x) - (t * a))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + t_1) tmp = 0.0 if (b <= -3.15e+94) tmp = t_2; elseif (b <= -0.0042) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + t_1); elseif (b <= 2e-14) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); elseif (b <= 1.15e+122) tmp = Float64(x * Float64(Float64(y * z) + Float64(Float64(t_1 / x) - Float64(t * a)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); t_2 = (y * ((x * z) - (i * j))) + t_1; tmp = 0.0; if (b <= -3.15e+94) tmp = t_2; elseif (b <= -0.0042) tmp = (t * ((c * j) - (x * a))) + t_1; elseif (b <= 2e-14) tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))); elseif (b <= 1.15e+122) tmp = x * ((y * z) + ((t_1 / x) - (t * a))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[b, -3.15e+94], t$95$2, If[LessEqual[b, -0.0042], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, 2e-14], 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], If[LessEqual[b, 1.15e+122], N[(x * N[(N[(y * z), $MachinePrecision] + N[(N[(t$95$1 / x), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := y \cdot \left(x \cdot z - i \cdot j\right) + t\_1\\
\mathbf{if}\;b \leq -3.15 \cdot 10^{+94}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -0.0042:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + t\_1\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-14}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;b \leq 1.15 \cdot 10^{+122}:\\
\;\;\;\;x \cdot \left(y \cdot z + \left(\frac{t\_1}{x} - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -3.15e94 or 1.15e122 < b Initial program 79.5%
Taylor expanded in t around 0 77.2%
*-commutative77.2%
associate-*r*78.2%
associate-*r*76.0%
associate-*r*76.0%
distribute-rgt-in77.2%
+-commutative77.2%
mul-1-neg77.2%
unsub-neg77.2%
*-commutative77.2%
Simplified77.2%
if -3.15e94 < b < -0.00419999999999999974Initial program 77.0%
Taylor expanded in y around 0 80.6%
+-commutative80.6%
*-commutative80.6%
associate-*r*80.6%
*-commutative80.6%
associate-*l*76.1%
mul-1-neg76.1%
associate-*r*76.2%
*-commutative76.2%
associate-*l*76.2%
distribute-rgt-neg-in76.2%
mul-1-neg76.2%
distribute-lft-in80.7%
mul-1-neg80.7%
unsub-neg80.7%
*-commutative80.7%
*-commutative80.7%
Simplified80.7%
if -0.00419999999999999974 < b < 2e-14Initial program 75.3%
Taylor expanded in b around 0 77.7%
if 2e-14 < b < 1.15e122Initial program 80.5%
Taylor expanded in x around inf 80.6%
associate--r+80.6%
sub-neg80.6%
mul-1-neg80.6%
+-commutative80.6%
associate-+r+80.6%
associate-+r-80.6%
+-commutative80.6%
div-sub80.6%
Simplified80.6%
Taylor expanded in j around 0 75.9%
Final simplification77.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))) (t_2 (* x (- (* y z) (* t a)))))
(if (<= x -1.5e+23)
t_2
(if (<= x -3.3e-96)
t_1
(if (<= x -2.4e-167)
(* b (- (* a i) (* z c)))
(if (<= x 4e-252)
(* j (- (* t c) (* y i)))
(if (<= x 2.05e-73)
t_1
(if (<= x 1.2e+53) (* 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 = c * ((t * j) - (z * b));
double t_2 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.5e+23) {
tmp = t_2;
} else if (x <= -3.3e-96) {
tmp = t_1;
} else if (x <= -2.4e-167) {
tmp = b * ((a * i) - (z * c));
} else if (x <= 4e-252) {
tmp = j * ((t * c) - (y * i));
} else if (x <= 2.05e-73) {
tmp = t_1;
} else if (x <= 1.2e+53) {
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 = c * ((t * j) - (z * b))
t_2 = x * ((y * z) - (t * a))
if (x <= (-1.5d+23)) then
tmp = t_2
else if (x <= (-3.3d-96)) then
tmp = t_1
else if (x <= (-2.4d-167)) then
tmp = b * ((a * i) - (z * c))
else if (x <= 4d-252) then
tmp = j * ((t * c) - (y * i))
else if (x <= 2.05d-73) then
tmp = t_1
else if (x <= 1.2d+53) 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 = c * ((t * j) - (z * b));
double t_2 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.5e+23) {
tmp = t_2;
} else if (x <= -3.3e-96) {
tmp = t_1;
} else if (x <= -2.4e-167) {
tmp = b * ((a * i) - (z * c));
} else if (x <= 4e-252) {
tmp = j * ((t * c) - (y * i));
} else if (x <= 2.05e-73) {
tmp = t_1;
} else if (x <= 1.2e+53) {
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 = c * ((t * j) - (z * b)) t_2 = x * ((y * z) - (t * a)) tmp = 0 if x <= -1.5e+23: tmp = t_2 elif x <= -3.3e-96: tmp = t_1 elif x <= -2.4e-167: tmp = b * ((a * i) - (z * c)) elif x <= 4e-252: tmp = j * ((t * c) - (y * i)) elif x <= 2.05e-73: tmp = t_1 elif x <= 1.2e+53: 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(c * Float64(Float64(t * j) - Float64(z * b))) t_2 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -1.5e+23) tmp = t_2; elseif (x <= -3.3e-96) tmp = t_1; elseif (x <= -2.4e-167) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (x <= 4e-252) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (x <= 2.05e-73) tmp = t_1; elseif (x <= 1.2e+53) 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 = c * ((t * j) - (z * b)); t_2 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -1.5e+23) tmp = t_2; elseif (x <= -3.3e-96) tmp = t_1; elseif (x <= -2.4e-167) tmp = b * ((a * i) - (z * c)); elseif (x <= 4e-252) tmp = j * ((t * c) - (y * i)); elseif (x <= 2.05e-73) tmp = t_1; elseif (x <= 1.2e+53) 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[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.5e+23], t$95$2, If[LessEqual[x, -3.3e-96], t$95$1, If[LessEqual[x, -2.4e-167], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4e-252], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.05e-73], t$95$1, If[LessEqual[x, 1.2e+53], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
t_2 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -1.5 \cdot 10^{+23}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -3.3 \cdot 10^{-96}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -2.4 \cdot 10^{-167}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;x \leq 4 \cdot 10^{-252}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;x \leq 2.05 \cdot 10^{-73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 1.2 \cdot 10^{+53}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.5e23 or 1.2e53 < x Initial program 79.6%
Taylor expanded in b around 0 71.2%
Taylor expanded in j around 0 64.6%
sub-neg64.6%
*-commutative64.6%
sub-neg64.6%
Simplified64.6%
if -1.5e23 < x < -3.2999999999999999e-96 or 3.99999999999999977e-252 < x < 2.05000000000000008e-73Initial program 71.6%
Taylor expanded in c around inf 57.4%
*-commutative57.4%
*-commutative57.4%
Simplified57.4%
if -3.2999999999999999e-96 < x < -2.39999999999999993e-167Initial program 83.3%
Taylor expanded in b around inf 76.0%
*-commutative76.0%
Simplified76.0%
if -2.39999999999999993e-167 < x < 3.99999999999999977e-252Initial program 76.0%
Taylor expanded in j around inf 69.0%
if 2.05000000000000008e-73 < x < 1.2e53Initial program 82.9%
Taylor expanded in y around inf 52.0%
+-commutative52.0%
mul-1-neg52.0%
unsub-neg52.0%
Simplified52.0%
Final simplification62.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -1.05e+109)
t_1
(if (<= c -9.6e-57)
(* a (- (* b i) (* x t)))
(if (<= c -3.6e-82)
(* z (- (* x y) (* b c)))
(if (<= c -1.02e-143)
(* x (- (* y z) (* t a)))
(if (<= c 6e-216)
(* y (- (* x z) (* i j)))
(if (<= c 1650000000000.0) (* i (- (* a b) (* y 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 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.05e+109) {
tmp = t_1;
} else if (c <= -9.6e-57) {
tmp = a * ((b * i) - (x * t));
} else if (c <= -3.6e-82) {
tmp = z * ((x * y) - (b * c));
} else if (c <= -1.02e-143) {
tmp = x * ((y * z) - (t * a));
} else if (c <= 6e-216) {
tmp = y * ((x * z) - (i * j));
} else if (c <= 1650000000000.0) {
tmp = i * ((a * b) - (y * 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 = c * ((t * j) - (z * b))
if (c <= (-1.05d+109)) then
tmp = t_1
else if (c <= (-9.6d-57)) then
tmp = a * ((b * i) - (x * t))
else if (c <= (-3.6d-82)) then
tmp = z * ((x * y) - (b * c))
else if (c <= (-1.02d-143)) then
tmp = x * ((y * z) - (t * a))
else if (c <= 6d-216) then
tmp = y * ((x * z) - (i * j))
else if (c <= 1650000000000.0d0) then
tmp = i * ((a * b) - (y * 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 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.05e+109) {
tmp = t_1;
} else if (c <= -9.6e-57) {
tmp = a * ((b * i) - (x * t));
} else if (c <= -3.6e-82) {
tmp = z * ((x * y) - (b * c));
} else if (c <= -1.02e-143) {
tmp = x * ((y * z) - (t * a));
} else if (c <= 6e-216) {
tmp = y * ((x * z) - (i * j));
} else if (c <= 1650000000000.0) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((t * j) - (z * b)) tmp = 0 if c <= -1.05e+109: tmp = t_1 elif c <= -9.6e-57: tmp = a * ((b * i) - (x * t)) elif c <= -3.6e-82: tmp = z * ((x * y) - (b * c)) elif c <= -1.02e-143: tmp = x * ((y * z) - (t * a)) elif c <= 6e-216: tmp = y * ((x * z) - (i * j)) elif c <= 1650000000000.0: tmp = i * ((a * b) - (y * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -1.05e+109) tmp = t_1; elseif (c <= -9.6e-57) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (c <= -3.6e-82) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (c <= -1.02e-143) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (c <= 6e-216) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (c <= 1650000000000.0) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -1.05e+109) tmp = t_1; elseif (c <= -9.6e-57) tmp = a * ((b * i) - (x * t)); elseif (c <= -3.6e-82) tmp = z * ((x * y) - (b * c)); elseif (c <= -1.02e-143) tmp = x * ((y * z) - (t * a)); elseif (c <= 6e-216) tmp = y * ((x * z) - (i * j)); elseif (c <= 1650000000000.0) tmp = i * ((a * b) - (y * 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[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.05e+109], t$95$1, If[LessEqual[c, -9.6e-57], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -3.6e-82], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.02e-143], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6e-216], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1650000000000.0], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -1.05 \cdot 10^{+109}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq -9.6 \cdot 10^{-57}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;c \leq -3.6 \cdot 10^{-82}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;c \leq -1.02 \cdot 10^{-143}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;c \leq 6 \cdot 10^{-216}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;c \leq 1650000000000:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -1.0500000000000001e109 or 1.65e12 < c Initial program 68.1%
Taylor expanded in c around inf 69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
if -1.0500000000000001e109 < c < -9.60000000000000025e-57Initial program 77.8%
Taylor expanded in a around inf 62.4%
distribute-lft-out--62.4%
*-commutative62.4%
Simplified62.4%
if -9.60000000000000025e-57 < c < -3.59999999999999998e-82Initial program 99.8%
Taylor expanded in z around inf 74.9%
if -3.59999999999999998e-82 < c < -1.02e-143Initial program 92.4%
Taylor expanded in b around 0 68.2%
Taylor expanded in j around 0 60.0%
sub-neg60.0%
*-commutative60.0%
sub-neg60.0%
Simplified60.0%
if -1.02e-143 < c < 6.00000000000000025e-216Initial program 89.0%
Taylor expanded in y around inf 60.8%
+-commutative60.8%
mul-1-neg60.8%
unsub-neg60.8%
Simplified60.8%
if 6.00000000000000025e-216 < c < 1.65e12Initial program 79.2%
Taylor expanded in i around inf 58.1%
distribute-lft-out--58.1%
*-commutative58.1%
Simplified58.1%
Taylor expanded in i around 0 58.1%
associate-*r*58.1%
mul-1-neg58.1%
*-commutative58.1%
Simplified58.1%
Final simplification64.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* x (- (* y z) (* t a))) (* i (* y j))))
(t_2 (* j (- (* t c) (* y i)))))
(if (<= j -7e-20)
t_2
(if (<= j -3.7e-125)
t_1
(if (<= j 5.2e-122)
(+ (* x (* y z)) (* b (- (* a i) (* z c))))
(if (<= j 1.92e+64) 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))) - (i * (y * j));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -7e-20) {
tmp = t_2;
} else if (j <= -3.7e-125) {
tmp = t_1;
} else if (j <= 5.2e-122) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 1.92e+64) {
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))) - (i * (y * j))
t_2 = j * ((t * c) - (y * i))
if (j <= (-7d-20)) then
tmp = t_2
else if (j <= (-3.7d-125)) then
tmp = t_1
else if (j <= 5.2d-122) then
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
else if (j <= 1.92d+64) 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))) - (i * (y * j));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -7e-20) {
tmp = t_2;
} else if (j <= -3.7e-125) {
tmp = t_1;
} else if (j <= 5.2e-122) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 1.92e+64) {
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))) - (i * (y * j)) t_2 = j * ((t * c) - (y * i)) tmp = 0 if j <= -7e-20: tmp = t_2 elif j <= -3.7e-125: tmp = t_1 elif j <= 5.2e-122: tmp = (x * (y * z)) + (b * ((a * i) - (z * c))) elif j <= 1.92e+64: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(i * Float64(y * j))) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -7e-20) tmp = t_2; elseif (j <= -3.7e-125) tmp = t_1; elseif (j <= 5.2e-122) tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (j <= 1.92e+64) 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))) - (i * (y * j)); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -7e-20) tmp = t_2; elseif (j <= -3.7e-125) tmp = t_1; elseif (j <= 5.2e-122) tmp = (x * (y * z)) + (b * ((a * i) - (z * c))); elseif (j <= 1.92e+64) 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[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -7e-20], t$95$2, If[LessEqual[j, -3.7e-125], t$95$1, If[LessEqual[j, 5.2e-122], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.92e+64], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right) - i \cdot \left(y \cdot j\right)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -7 \cdot 10^{-20}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq -3.7 \cdot 10^{-125}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 5.2 \cdot 10^{-122}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 1.92 \cdot 10^{+64}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -7.00000000000000007e-20 or 1.92e64 < j Initial program 77.8%
Taylor expanded in j around inf 64.4%
if -7.00000000000000007e-20 < j < -3.6999999999999999e-125 or 5.1999999999999995e-122 < j < 1.92e64Initial program 85.6%
Taylor expanded in b around 0 72.6%
Taylor expanded in c around 0 66.3%
+-commutative66.3%
sub-neg66.3%
*-commutative66.3%
sub-neg66.3%
mul-1-neg66.3%
unsub-neg66.3%
Simplified66.3%
if -3.6999999999999999e-125 < j < 5.1999999999999995e-122Initial program 71.3%
Taylor expanded in t around 0 72.5%
*-commutative72.5%
associate-*r*71.1%
associate-*r*71.1%
associate-*r*71.1%
distribute-rgt-in71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
*-commutative71.1%
Simplified71.1%
Taylor expanded in x around inf 69.9%
Final simplification66.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))) (t_2 (* i (- (* a b) (* y j)))))
(if (<= i -2.7e-20)
t_2
(if (<= i -1.6e-190)
t_1
(if (<= i 6e-306)
(* t (- (* c j) (* x a)))
(if (<= i 2.3e-210)
(* c (- (* t j) (* z b)))
(if (<= i 1.8e+74) 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 = i * ((a * b) - (y * j));
double tmp;
if (i <= -2.7e-20) {
tmp = t_2;
} else if (i <= -1.6e-190) {
tmp = t_1;
} else if (i <= 6e-306) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 2.3e-210) {
tmp = c * ((t * j) - (z * b));
} else if (i <= 1.8e+74) {
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))
t_2 = i * ((a * b) - (y * j))
if (i <= (-2.7d-20)) then
tmp = t_2
else if (i <= (-1.6d-190)) then
tmp = t_1
else if (i <= 6d-306) then
tmp = t * ((c * j) - (x * a))
else if (i <= 2.3d-210) then
tmp = c * ((t * j) - (z * b))
else if (i <= 1.8d+74) 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));
double t_2 = i * ((a * b) - (y * j));
double tmp;
if (i <= -2.7e-20) {
tmp = t_2;
} else if (i <= -1.6e-190) {
tmp = t_1;
} else if (i <= 6e-306) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 2.3e-210) {
tmp = c * ((t * j) - (z * b));
} else if (i <= 1.8e+74) {
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)) t_2 = i * ((a * b) - (y * j)) tmp = 0 if i <= -2.7e-20: tmp = t_2 elif i <= -1.6e-190: tmp = t_1 elif i <= 6e-306: tmp = t * ((c * j) - (x * a)) elif i <= 2.3e-210: tmp = c * ((t * j) - (z * b)) elif i <= 1.8e+74: tmp = t_1 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(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (i <= -2.7e-20) tmp = t_2; elseif (i <= -1.6e-190) tmp = t_1; elseif (i <= 6e-306) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (i <= 2.3e-210) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (i <= 1.8e+74) 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)); t_2 = i * ((a * b) - (y * j)); tmp = 0.0; if (i <= -2.7e-20) tmp = t_2; elseif (i <= -1.6e-190) tmp = t_1; elseif (i <= 6e-306) tmp = t * ((c * j) - (x * a)); elseif (i <= 2.3e-210) tmp = c * ((t * j) - (z * b)); elseif (i <= 1.8e+74) 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[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.7e-20], t$95$2, If[LessEqual[i, -1.6e-190], t$95$1, If[LessEqual[i, 6e-306], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.3e-210], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.8e+74], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -2.7 \cdot 10^{-20}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;i \leq -1.6 \cdot 10^{-190}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 6 \cdot 10^{-306}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;i \leq 2.3 \cdot 10^{-210}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;i \leq 1.8 \cdot 10^{+74}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if i < -2.7e-20 or 1.79999999999999994e74 < i Initial program 72.1%
Taylor expanded in i around inf 66.8%
distribute-lft-out--66.8%
*-commutative66.8%
Simplified66.8%
Taylor expanded in i around 0 66.8%
associate-*r*66.8%
mul-1-neg66.8%
*-commutative66.8%
Simplified66.8%
if -2.7e-20 < i < -1.6e-190 or 2.3e-210 < i < 1.79999999999999994e74Initial program 83.2%
Taylor expanded in b around 0 71.7%
Taylor expanded in j around 0 55.5%
sub-neg55.5%
*-commutative55.5%
sub-neg55.5%
Simplified55.5%
if -1.6e-190 < i < 6.00000000000000048e-306Initial program 66.2%
Taylor expanded in t around inf 77.2%
+-commutative77.2%
mul-1-neg77.2%
unsub-neg77.2%
*-commutative77.2%
Simplified77.2%
if 6.00000000000000048e-306 < i < 2.3e-210Initial program 88.6%
Taylor expanded in c around inf 63.0%
*-commutative63.0%
*-commutative63.0%
Simplified63.0%
Final simplification62.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))) (t_2 (* i (- (* a b) (* y j)))))
(if (<= i -2.35e-23)
t_2
(if (<= i -3.8e-191)
t_1
(if (<= i 8.5e-307)
(* t (- (* c j) (* x a)))
(if (<= i 1.15e-210)
(* (* x z) (- y (* b (/ c x))))
(if (<= i 1.16e+78) 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 = i * ((a * b) - (y * j));
double tmp;
if (i <= -2.35e-23) {
tmp = t_2;
} else if (i <= -3.8e-191) {
tmp = t_1;
} else if (i <= 8.5e-307) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 1.15e-210) {
tmp = (x * z) * (y - (b * (c / x)));
} else if (i <= 1.16e+78) {
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))
t_2 = i * ((a * b) - (y * j))
if (i <= (-2.35d-23)) then
tmp = t_2
else if (i <= (-3.8d-191)) then
tmp = t_1
else if (i <= 8.5d-307) then
tmp = t * ((c * j) - (x * a))
else if (i <= 1.15d-210) then
tmp = (x * z) * (y - (b * (c / x)))
else if (i <= 1.16d+78) 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));
double t_2 = i * ((a * b) - (y * j));
double tmp;
if (i <= -2.35e-23) {
tmp = t_2;
} else if (i <= -3.8e-191) {
tmp = t_1;
} else if (i <= 8.5e-307) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 1.15e-210) {
tmp = (x * z) * (y - (b * (c / x)));
} else if (i <= 1.16e+78) {
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)) t_2 = i * ((a * b) - (y * j)) tmp = 0 if i <= -2.35e-23: tmp = t_2 elif i <= -3.8e-191: tmp = t_1 elif i <= 8.5e-307: tmp = t * ((c * j) - (x * a)) elif i <= 1.15e-210: tmp = (x * z) * (y - (b * (c / x))) elif i <= 1.16e+78: tmp = t_1 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(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (i <= -2.35e-23) tmp = t_2; elseif (i <= -3.8e-191) tmp = t_1; elseif (i <= 8.5e-307) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (i <= 1.15e-210) tmp = Float64(Float64(x * z) * Float64(y - Float64(b * Float64(c / x)))); elseif (i <= 1.16e+78) 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)); t_2 = i * ((a * b) - (y * j)); tmp = 0.0; if (i <= -2.35e-23) tmp = t_2; elseif (i <= -3.8e-191) tmp = t_1; elseif (i <= 8.5e-307) tmp = t * ((c * j) - (x * a)); elseif (i <= 1.15e-210) tmp = (x * z) * (y - (b * (c / x))); elseif (i <= 1.16e+78) 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[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -2.35e-23], t$95$2, If[LessEqual[i, -3.8e-191], t$95$1, If[LessEqual[i, 8.5e-307], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.15e-210], N[(N[(x * z), $MachinePrecision] * N[(y - N[(b * N[(c / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.16e+78], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -2.35 \cdot 10^{-23}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;i \leq -3.8 \cdot 10^{-191}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 8.5 \cdot 10^{-307}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;i \leq 1.15 \cdot 10^{-210}:\\
\;\;\;\;\left(x \cdot z\right) \cdot \left(y - b \cdot \frac{c}{x}\right)\\
\mathbf{elif}\;i \leq 1.16 \cdot 10^{+78}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if i < -2.35e-23 or 1.1600000000000001e78 < i Initial program 72.1%
Taylor expanded in i around inf 66.8%
distribute-lft-out--66.8%
*-commutative66.8%
Simplified66.8%
Taylor expanded in i around 0 66.8%
associate-*r*66.8%
mul-1-neg66.8%
*-commutative66.8%
Simplified66.8%
if -2.35e-23 < i < -3.7999999999999998e-191 or 1.15e-210 < i < 1.1600000000000001e78Initial program 83.2%
Taylor expanded in b around 0 71.7%
Taylor expanded in j around 0 55.5%
sub-neg55.5%
*-commutative55.5%
sub-neg55.5%
Simplified55.5%
if -3.7999999999999998e-191 < i < 8.4999999999999995e-307Initial program 68.9%
Taylor expanded in t around inf 80.4%
+-commutative80.4%
mul-1-neg80.4%
unsub-neg80.4%
*-commutative80.4%
Simplified80.4%
if 8.4999999999999995e-307 < i < 1.15e-210Initial program 84.3%
Taylor expanded in x around inf 69.3%
associate--r+69.3%
sub-neg69.3%
mul-1-neg69.3%
+-commutative69.3%
associate-+r+69.3%
associate-+r-69.3%
+-commutative69.3%
div-sub75.0%
Simplified75.0%
Taylor expanded in z around inf 54.9%
associate-*r*59.2%
*-commutative59.2%
associate-/l*68.9%
Simplified68.9%
Final simplification63.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* y z) (* t a)))
(t_2 (+ (* x t_1) (* j (- (* t c) (* y i))))))
(if (<= j -1.05e-119)
t_2
(if (<= j 2.5e-278)
(+ (* x (* y z)) (* b (- (* a i) (* z c))))
(if (<= j 7.8e-33) (* x (+ t_1 (/ (* a (* b i)) x))) 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 * z) - (t * a);
double t_2 = (x * t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (j <= -1.05e-119) {
tmp = t_2;
} else if (j <= 2.5e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 7.8e-33) {
tmp = x * (t_1 + ((a * (b * i)) / x));
} 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 * z) - (t * a)
t_2 = (x * t_1) + (j * ((t * c) - (y * i)))
if (j <= (-1.05d-119)) then
tmp = t_2
else if (j <= 2.5d-278) then
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)))
else if (j <= 7.8d-33) then
tmp = x * (t_1 + ((a * (b * i)) / x))
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 * z) - (t * a);
double t_2 = (x * t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (j <= -1.05e-119) {
tmp = t_2;
} else if (j <= 2.5e-278) {
tmp = (x * (y * z)) + (b * ((a * i) - (z * c)));
} else if (j <= 7.8e-33) {
tmp = x * (t_1 + ((a * (b * i)) / x));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (y * z) - (t * a) t_2 = (x * t_1) + (j * ((t * c) - (y * i))) tmp = 0 if j <= -1.05e-119: tmp = t_2 elif j <= 2.5e-278: tmp = (x * (y * z)) + (b * ((a * i) - (z * c))) elif j <= 7.8e-33: tmp = x * (t_1 + ((a * (b * i)) / x)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(y * z) - Float64(t * a)) t_2 = Float64(Float64(x * t_1) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (j <= -1.05e-119) tmp = t_2; elseif (j <= 2.5e-278) tmp = Float64(Float64(x * Float64(y * z)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (j <= 7.8e-33) tmp = Float64(x * Float64(t_1 + Float64(Float64(a * Float64(b * i)) / x))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (y * z) - (t * a); t_2 = (x * t_1) + (j * ((t * c) - (y * i))); tmp = 0.0; if (j <= -1.05e-119) tmp = t_2; elseif (j <= 2.5e-278) tmp = (x * (y * z)) + (b * ((a * i) - (z * c))); elseif (j <= 7.8e-33) tmp = x * (t_1 + ((a * (b * i)) / x)); 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[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * t$95$1), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.05e-119], t$95$2, If[LessEqual[j, 2.5e-278], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.8e-33], N[(x * N[(t$95$1 + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot z - t \cdot a\\
t_2 := x \cdot t\_1 + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -1.05 \cdot 10^{-119}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq 2.5 \cdot 10^{-278}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 7.8 \cdot 10^{-33}:\\
\;\;\;\;x \cdot \left(t\_1 + \frac{a \cdot \left(b \cdot i\right)}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -1.05e-119 or 7.79999999999999948e-33 < j Initial program 79.8%
Taylor expanded in b around 0 73.1%
if -1.05e-119 < j < 2.49999999999999992e-278Initial program 82.7%
Taylor expanded in t around 0 82.7%
*-commutative82.7%
associate-*r*80.3%
associate-*r*80.3%
associate-*r*80.3%
distribute-rgt-in80.3%
+-commutative80.3%
mul-1-neg80.3%
unsub-neg80.3%
*-commutative80.3%
Simplified80.3%
Taylor expanded in x around inf 78.0%
if 2.49999999999999992e-278 < j < 7.79999999999999948e-33Initial program 66.8%
Taylor expanded in x around inf 67.1%
associate--r+67.1%
sub-neg67.1%
mul-1-neg67.1%
+-commutative67.1%
associate-+r+67.1%
associate-+r-67.1%
+-commutative67.1%
div-sub67.1%
Simplified67.1%
Taylor expanded in a around inf 72.4%
Final simplification73.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* y z) (* t a)))
(t_2 (+ (* x t_1) (* j (- (* t c) (* y i))))))
(if (<= j -6e-109)
t_2
(if (<= j 3.5e-274)
(+ (* y (- (* x z) (* i j))) (* b (- (* a i) (* z c))))
(if (<= j 3.8e-34) (* x (+ t_1 (/ (* a (* b i)) x))) 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 * z) - (t * a);
double t_2 = (x * t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (j <= -6e-109) {
tmp = t_2;
} else if (j <= 3.5e-274) {
tmp = (y * ((x * z) - (i * j))) + (b * ((a * i) - (z * c)));
} else if (j <= 3.8e-34) {
tmp = x * (t_1 + ((a * (b * i)) / x));
} 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 * z) - (t * a)
t_2 = (x * t_1) + (j * ((t * c) - (y * i)))
if (j <= (-6d-109)) then
tmp = t_2
else if (j <= 3.5d-274) then
tmp = (y * ((x * z) - (i * j))) + (b * ((a * i) - (z * c)))
else if (j <= 3.8d-34) then
tmp = x * (t_1 + ((a * (b * i)) / x))
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 * z) - (t * a);
double t_2 = (x * t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (j <= -6e-109) {
tmp = t_2;
} else if (j <= 3.5e-274) {
tmp = (y * ((x * z) - (i * j))) + (b * ((a * i) - (z * c)));
} else if (j <= 3.8e-34) {
tmp = x * (t_1 + ((a * (b * i)) / x));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (y * z) - (t * a) t_2 = (x * t_1) + (j * ((t * c) - (y * i))) tmp = 0 if j <= -6e-109: tmp = t_2 elif j <= 3.5e-274: tmp = (y * ((x * z) - (i * j))) + (b * ((a * i) - (z * c))) elif j <= 3.8e-34: tmp = x * (t_1 + ((a * (b * i)) / x)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(y * z) - Float64(t * a)) t_2 = Float64(Float64(x * t_1) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (j <= -6e-109) tmp = t_2; elseif (j <= 3.5e-274) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (j <= 3.8e-34) tmp = Float64(x * Float64(t_1 + Float64(Float64(a * Float64(b * i)) / x))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (y * z) - (t * a); t_2 = (x * t_1) + (j * ((t * c) - (y * i))); tmp = 0.0; if (j <= -6e-109) tmp = t_2; elseif (j <= 3.5e-274) tmp = (y * ((x * z) - (i * j))) + (b * ((a * i) - (z * c))); elseif (j <= 3.8e-34) tmp = x * (t_1 + ((a * (b * i)) / x)); 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[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * t$95$1), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -6e-109], t$95$2, If[LessEqual[j, 3.5e-274], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 3.8e-34], N[(x * N[(t$95$1 + N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot z - t \cdot a\\
t_2 := x \cdot t\_1 + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -6 \cdot 10^{-109}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq 3.5 \cdot 10^{-274}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;j \leq 3.8 \cdot 10^{-34}:\\
\;\;\;\;x \cdot \left(t\_1 + \frac{a \cdot \left(b \cdot i\right)}{x}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -6.00000000000000043e-109 or 3.8000000000000001e-34 < j Initial program 80.0%
Taylor expanded in b around 0 73.4%
if -6.00000000000000043e-109 < j < 3.49999999999999982e-274Initial program 82.1%
Taylor expanded in t around 0 80.2%
*-commutative80.2%
associate-*r*80.1%
associate-*r*80.1%
associate-*r*80.1%
distribute-rgt-in80.1%
+-commutative80.1%
mul-1-neg80.1%
unsub-neg80.1%
*-commutative80.1%
Simplified80.1%
if 3.49999999999999982e-274 < j < 3.8000000000000001e-34Initial program 66.2%
Taylor expanded in x around inf 66.5%
associate--r+66.5%
sub-neg66.5%
mul-1-neg66.5%
+-commutative66.5%
associate-+r+66.5%
associate-+r-66.5%
+-commutative66.5%
div-sub66.5%
Simplified66.5%
Taylor expanded in a around inf 71.9%
Final simplification74.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (* y (- j)))) (t_2 (* c (* t j))))
(if (<= t -2.25e+51)
t_2
(if (<= t -8.2e-173)
t_1
(if (<= t 4.1e-218)
(* x (* y z))
(if (<= t 1.55e-153) (* i (* a b)) (if (<= t 8.5e+127) 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 * (y * -j);
double t_2 = c * (t * j);
double tmp;
if (t <= -2.25e+51) {
tmp = t_2;
} else if (t <= -8.2e-173) {
tmp = t_1;
} else if (t <= 4.1e-218) {
tmp = x * (y * z);
} else if (t <= 1.55e-153) {
tmp = i * (a * b);
} else if (t <= 8.5e+127) {
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 * (y * -j)
t_2 = c * (t * j)
if (t <= (-2.25d+51)) then
tmp = t_2
else if (t <= (-8.2d-173)) then
tmp = t_1
else if (t <= 4.1d-218) then
tmp = x * (y * z)
else if (t <= 1.55d-153) then
tmp = i * (a * b)
else if (t <= 8.5d+127) 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 * (y * -j);
double t_2 = c * (t * j);
double tmp;
if (t <= -2.25e+51) {
tmp = t_2;
} else if (t <= -8.2e-173) {
tmp = t_1;
} else if (t <= 4.1e-218) {
tmp = x * (y * z);
} else if (t <= 1.55e-153) {
tmp = i * (a * b);
} else if (t <= 8.5e+127) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * (y * -j) t_2 = c * (t * j) tmp = 0 if t <= -2.25e+51: tmp = t_2 elif t <= -8.2e-173: tmp = t_1 elif t <= 4.1e-218: tmp = x * (y * z) elif t <= 1.55e-153: tmp = i * (a * b) elif t <= 8.5e+127: 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(y * Float64(-j))) t_2 = Float64(c * Float64(t * j)) tmp = 0.0 if (t <= -2.25e+51) tmp = t_2; elseif (t <= -8.2e-173) tmp = t_1; elseif (t <= 4.1e-218) tmp = Float64(x * Float64(y * z)); elseif (t <= 1.55e-153) tmp = Float64(i * Float64(a * b)); elseif (t <= 8.5e+127) 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 * (y * -j); t_2 = c * (t * j); tmp = 0.0; if (t <= -2.25e+51) tmp = t_2; elseif (t <= -8.2e-173) tmp = t_1; elseif (t <= 4.1e-218) tmp = x * (y * z); elseif (t <= 1.55e-153) tmp = i * (a * b); elseif (t <= 8.5e+127) 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[(y * (-j)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -2.25e+51], t$95$2, If[LessEqual[t, -8.2e-173], t$95$1, If[LessEqual[t, 4.1e-218], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.55e-153], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8.5e+127], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(y \cdot \left(-j\right)\right)\\
t_2 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;t \leq -2.25 \cdot 10^{+51}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -8.2 \cdot 10^{-173}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4.1 \cdot 10^{-218}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 1.55 \cdot 10^{-153}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 8.5 \cdot 10^{+127}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -2.25e51 or 8.4999999999999997e127 < t Initial program 72.2%
Taylor expanded in x around inf 68.1%
associate--r+68.1%
sub-neg68.1%
mul-1-neg68.1%
+-commutative68.1%
associate-+r+68.1%
associate-+r-68.1%
+-commutative68.1%
div-sub68.1%
Simplified68.1%
Taylor expanded in c around inf 54.9%
associate-*r*54.7%
associate-/l*52.3%
associate-/l*47.7%
Simplified47.7%
Taylor expanded in z around inf 57.1%
+-commutative57.1%
mul-1-neg57.1%
unsub-neg57.1%
associate-*r*53.8%
*-commutative53.8%
*-commutative53.8%
Simplified53.8%
Taylor expanded in z around 0 53.6%
if -2.25e51 < t < -8.1999999999999995e-173 or 1.54999999999999997e-153 < t < 8.4999999999999997e127Initial program 79.7%
Taylor expanded in t around 0 62.9%
*-commutative62.9%
associate-*r*64.7%
associate-*r*63.0%
associate-*r*63.0%
distribute-rgt-in63.0%
+-commutative63.0%
mul-1-neg63.0%
unsub-neg63.0%
*-commutative63.0%
Simplified63.0%
Taylor expanded in j around inf 32.0%
mul-1-neg32.0%
*-commutative32.0%
distribute-rgt-neg-out32.0%
distribute-rgt-neg-in32.0%
Simplified32.0%
if -8.1999999999999995e-173 < t < 4.0999999999999998e-218Initial program 81.8%
Taylor expanded in y around inf 46.2%
+-commutative46.2%
mul-1-neg46.2%
unsub-neg46.2%
Simplified46.2%
Taylor expanded in x around inf 39.6%
if 4.0999999999999998e-218 < t < 1.54999999999999997e-153Initial program 80.8%
Taylor expanded in b around inf 61.3%
*-commutative61.3%
Simplified61.3%
Taylor expanded in a around inf 46.4%
associate-*r*59.1%
*-commutative59.1%
Simplified59.1%
Final simplification42.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (* t j))))
(if (<= t -1.02e+46)
t_1
(if (<= t 4e-219)
(* x (* y z))
(if (<= t 9.5e-59)
(* b (* a i))
(if (<= t 3.8e+44)
(* j (* t c))
(if (<= t 8e+107) (* a (* b i)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -1.02e+46) {
tmp = t_1;
} else if (t <= 4e-219) {
tmp = x * (y * z);
} else if (t <= 9.5e-59) {
tmp = b * (a * i);
} else if (t <= 3.8e+44) {
tmp = j * (t * c);
} else if (t <= 8e+107) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * (t * j)
if (t <= (-1.02d+46)) then
tmp = t_1
else if (t <= 4d-219) then
tmp = x * (y * z)
else if (t <= 9.5d-59) then
tmp = b * (a * i)
else if (t <= 3.8d+44) then
tmp = j * (t * c)
else if (t <= 8d+107) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -1.02e+46) {
tmp = t_1;
} else if (t <= 4e-219) {
tmp = x * (y * z);
} else if (t <= 9.5e-59) {
tmp = b * (a * i);
} else if (t <= 3.8e+44) {
tmp = j * (t * c);
} else if (t <= 8e+107) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if t <= -1.02e+46: tmp = t_1 elif t <= 4e-219: tmp = x * (y * z) elif t <= 9.5e-59: tmp = b * (a * i) elif t <= 3.8e+44: tmp = j * (t * c) elif t <= 8e+107: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (t <= -1.02e+46) tmp = t_1; elseif (t <= 4e-219) tmp = Float64(x * Float64(y * z)); elseif (t <= 9.5e-59) tmp = Float64(b * Float64(a * i)); elseif (t <= 3.8e+44) tmp = Float64(j * Float64(t * c)); elseif (t <= 8e+107) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (t <= -1.02e+46) tmp = t_1; elseif (t <= 4e-219) tmp = x * (y * z); elseif (t <= 9.5e-59) tmp = b * (a * i); elseif (t <= 3.8e+44) tmp = j * (t * c); elseif (t <= 8e+107) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.02e+46], t$95$1, If[LessEqual[t, 4e-219], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 9.5e-59], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 3.8e+44], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 8e+107], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;t \leq -1.02 \cdot 10^{+46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4 \cdot 10^{-219}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 9.5 \cdot 10^{-59}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;t \leq 3.8 \cdot 10^{+44}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;t \leq 8 \cdot 10^{+107}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.0199999999999999e46 or 7.9999999999999998e107 < t Initial program 73.7%
Taylor expanded in x around inf 67.7%
associate--r+67.7%
sub-neg67.7%
mul-1-neg67.7%
+-commutative67.7%
associate-+r+67.7%
associate-+r-67.7%
+-commutative67.7%
div-sub67.8%
Simplified67.8%
Taylor expanded in c around inf 53.0%
associate-*r*52.9%
associate-/l*50.6%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in z around inf 54.0%
+-commutative54.0%
mul-1-neg54.0%
unsub-neg54.0%
associate-*r*50.9%
*-commutative50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in z around 0 51.8%
if -1.0199999999999999e46 < t < 4.0000000000000001e-219Initial program 80.9%
Taylor expanded in y around inf 46.2%
+-commutative46.2%
mul-1-neg46.2%
unsub-neg46.2%
Simplified46.2%
Taylor expanded in x around inf 31.9%
if 4.0000000000000001e-219 < t < 9.4999999999999994e-59Initial program 80.5%
Taylor expanded in b around inf 41.5%
*-commutative41.5%
Simplified41.5%
Taylor expanded in a around inf 32.2%
*-commutative32.2%
Simplified32.2%
if 9.4999999999999994e-59 < t < 3.8000000000000002e44Initial program 88.1%
Taylor expanded in x around inf 71.4%
associate--r+71.4%
sub-neg71.4%
mul-1-neg71.4%
+-commutative71.4%
associate-+r+71.4%
associate-+r-71.4%
+-commutative71.4%
div-sub83.2%
Simplified83.2%
Taylor expanded in c around inf 53.4%
associate-*r*47.2%
associate-/l*47.2%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in z around inf 42.8%
+-commutative42.8%
mul-1-neg42.8%
unsub-neg42.8%
associate-*r*42.9%
*-commutative42.9%
*-commutative42.9%
Simplified42.9%
Taylor expanded in z around 0 37.1%
*-commutative37.1%
associate-*r*37.2%
*-commutative37.2%
Simplified37.2%
if 3.8000000000000002e44 < t < 7.9999999999999998e107Initial program 60.0%
Taylor expanded in b around inf 36.1%
*-commutative36.1%
Simplified36.1%
Taylor expanded in a around inf 30.5%
Final simplification39.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (* t j))))
(if (<= t -3.4e+46)
t_1
(if (<= t 2e-218)
(* x (* y z))
(if (<= t 2.5e-153)
(* i (* a b))
(if (<= t 0.0029)
(* y (* x z))
(if (<= t 1.3e+108) (* a (* b i)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -3.4e+46) {
tmp = t_1;
} else if (t <= 2e-218) {
tmp = x * (y * z);
} else if (t <= 2.5e-153) {
tmp = i * (a * b);
} else if (t <= 0.0029) {
tmp = y * (x * z);
} else if (t <= 1.3e+108) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * (t * j)
if (t <= (-3.4d+46)) then
tmp = t_1
else if (t <= 2d-218) then
tmp = x * (y * z)
else if (t <= 2.5d-153) then
tmp = i * (a * b)
else if (t <= 0.0029d0) then
tmp = y * (x * z)
else if (t <= 1.3d+108) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -3.4e+46) {
tmp = t_1;
} else if (t <= 2e-218) {
tmp = x * (y * z);
} else if (t <= 2.5e-153) {
tmp = i * (a * b);
} else if (t <= 0.0029) {
tmp = y * (x * z);
} else if (t <= 1.3e+108) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if t <= -3.4e+46: tmp = t_1 elif t <= 2e-218: tmp = x * (y * z) elif t <= 2.5e-153: tmp = i * (a * b) elif t <= 0.0029: tmp = y * (x * z) elif t <= 1.3e+108: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (t <= -3.4e+46) tmp = t_1; elseif (t <= 2e-218) tmp = Float64(x * Float64(y * z)); elseif (t <= 2.5e-153) tmp = Float64(i * Float64(a * b)); elseif (t <= 0.0029) tmp = Float64(y * Float64(x * z)); elseif (t <= 1.3e+108) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (t <= -3.4e+46) tmp = t_1; elseif (t <= 2e-218) tmp = x * (y * z); elseif (t <= 2.5e-153) tmp = i * (a * b); elseif (t <= 0.0029) tmp = y * (x * z); elseif (t <= 1.3e+108) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.4e+46], t$95$1, If[LessEqual[t, 2e-218], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.5e-153], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.0029], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.3e+108], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;t \leq -3.4 \cdot 10^{+46}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 2 \cdot 10^{-218}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 2.5 \cdot 10^{-153}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 0.0029:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;t \leq 1.3 \cdot 10^{+108}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.3999999999999998e46 or 1.3000000000000001e108 < t Initial program 73.7%
Taylor expanded in x around inf 67.7%
associate--r+67.7%
sub-neg67.7%
mul-1-neg67.7%
+-commutative67.7%
associate-+r+67.7%
associate-+r-67.7%
+-commutative67.7%
div-sub67.8%
Simplified67.8%
Taylor expanded in c around inf 53.0%
associate-*r*52.9%
associate-/l*50.6%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in z around inf 54.0%
+-commutative54.0%
mul-1-neg54.0%
unsub-neg54.0%
associate-*r*50.9%
*-commutative50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in z around 0 51.8%
if -3.3999999999999998e46 < t < 2.0000000000000001e-218Initial program 80.9%
Taylor expanded in y around inf 46.2%
+-commutative46.2%
mul-1-neg46.2%
unsub-neg46.2%
Simplified46.2%
Taylor expanded in x around inf 31.9%
if 2.0000000000000001e-218 < t < 2.50000000000000016e-153Initial program 80.8%
Taylor expanded in b around inf 61.3%
*-commutative61.3%
Simplified61.3%
Taylor expanded in a around inf 46.4%
associate-*r*59.1%
*-commutative59.1%
Simplified59.1%
if 2.50000000000000016e-153 < t < 0.0029Initial program 80.2%
Taylor expanded in y around inf 42.1%
+-commutative42.1%
mul-1-neg42.1%
unsub-neg42.1%
Simplified42.1%
Taylor expanded in x around inf 25.2%
*-commutative25.2%
Simplified25.2%
if 0.0029 < t < 1.3000000000000001e108Initial program 73.3%
Taylor expanded in b around inf 34.0%
*-commutative34.0%
Simplified34.0%
Taylor expanded in a around inf 30.3%
Final simplification39.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (* t j))))
(if (<= t -3.6e+45)
t_1
(if (<= t 3.7e-219)
(* x (* y z))
(if (<= t 4.5e-154)
(* i (* a b))
(if (<= t 0.0038)
(* z (* x y))
(if (<= t 2.1e+113) (* a (* b i)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -3.6e+45) {
tmp = t_1;
} else if (t <= 3.7e-219) {
tmp = x * (y * z);
} else if (t <= 4.5e-154) {
tmp = i * (a * b);
} else if (t <= 0.0038) {
tmp = z * (x * y);
} else if (t <= 2.1e+113) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * (t * j)
if (t <= (-3.6d+45)) then
tmp = t_1
else if (t <= 3.7d-219) then
tmp = x * (y * z)
else if (t <= 4.5d-154) then
tmp = i * (a * b)
else if (t <= 0.0038d0) then
tmp = z * (x * y)
else if (t <= 2.1d+113) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -3.6e+45) {
tmp = t_1;
} else if (t <= 3.7e-219) {
tmp = x * (y * z);
} else if (t <= 4.5e-154) {
tmp = i * (a * b);
} else if (t <= 0.0038) {
tmp = z * (x * y);
} else if (t <= 2.1e+113) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if t <= -3.6e+45: tmp = t_1 elif t <= 3.7e-219: tmp = x * (y * z) elif t <= 4.5e-154: tmp = i * (a * b) elif t <= 0.0038: tmp = z * (x * y) elif t <= 2.1e+113: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (t <= -3.6e+45) tmp = t_1; elseif (t <= 3.7e-219) tmp = Float64(x * Float64(y * z)); elseif (t <= 4.5e-154) tmp = Float64(i * Float64(a * b)); elseif (t <= 0.0038) tmp = Float64(z * Float64(x * y)); elseif (t <= 2.1e+113) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (t <= -3.6e+45) tmp = t_1; elseif (t <= 3.7e-219) tmp = x * (y * z); elseif (t <= 4.5e-154) tmp = i * (a * b); elseif (t <= 0.0038) tmp = z * (x * y); elseif (t <= 2.1e+113) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.6e+45], t$95$1, If[LessEqual[t, 3.7e-219], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 4.5e-154], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 0.0038], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 2.1e+113], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;t \leq -3.6 \cdot 10^{+45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 3.7 \cdot 10^{-219}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 4.5 \cdot 10^{-154}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 0.0038:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;t \leq 2.1 \cdot 10^{+113}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.6e45 or 2.0999999999999999e113 < t Initial program 73.7%
Taylor expanded in x around inf 67.7%
associate--r+67.7%
sub-neg67.7%
mul-1-neg67.7%
+-commutative67.7%
associate-+r+67.7%
associate-+r-67.7%
+-commutative67.7%
div-sub67.8%
Simplified67.8%
Taylor expanded in c around inf 53.0%
associate-*r*52.9%
associate-/l*50.6%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in z around inf 54.0%
+-commutative54.0%
mul-1-neg54.0%
unsub-neg54.0%
associate-*r*50.9%
*-commutative50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in z around 0 51.8%
if -3.6e45 < t < 3.7e-219Initial program 80.9%
Taylor expanded in y around inf 46.2%
+-commutative46.2%
mul-1-neg46.2%
unsub-neg46.2%
Simplified46.2%
Taylor expanded in x around inf 31.9%
if 3.7e-219 < t < 4.4999999999999997e-154Initial program 80.8%
Taylor expanded in b around inf 61.3%
*-commutative61.3%
Simplified61.3%
Taylor expanded in a around inf 46.4%
associate-*r*59.1%
*-commutative59.1%
Simplified59.1%
if 4.4999999999999997e-154 < t < 0.00379999999999999999Initial program 80.2%
Taylor expanded in t around 0 58.0%
*-commutative58.0%
associate-*r*61.0%
associate-*r*57.8%
associate-*r*57.8%
distribute-rgt-in57.8%
+-commutative57.8%
mul-1-neg57.8%
unsub-neg57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in x around inf 22.2%
associate-*r*25.3%
*-commutative25.3%
Simplified25.3%
if 0.00379999999999999999 < t < 2.0999999999999999e113Initial program 73.3%
Taylor expanded in b around inf 34.0%
*-commutative34.0%
Simplified34.0%
Taylor expanded in a around inf 30.3%
Final simplification39.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (* t j))))
(if (<= t -4e+45)
t_1
(if (<= t 5e-218)
(* x (* y z))
(if (<= t 1.2e-128)
(* i (* a b))
(if (<= t 6.1e-5)
(* c (* z (- b)))
(if (<= t 1.15e+108) (* a (* b i)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -4e+45) {
tmp = t_1;
} else if (t <= 5e-218) {
tmp = x * (y * z);
} else if (t <= 1.2e-128) {
tmp = i * (a * b);
} else if (t <= 6.1e-5) {
tmp = c * (z * -b);
} else if (t <= 1.15e+108) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * (t * j)
if (t <= (-4d+45)) then
tmp = t_1
else if (t <= 5d-218) then
tmp = x * (y * z)
else if (t <= 1.2d-128) then
tmp = i * (a * b)
else if (t <= 6.1d-5) then
tmp = c * (z * -b)
else if (t <= 1.15d+108) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * (t * j);
double tmp;
if (t <= -4e+45) {
tmp = t_1;
} else if (t <= 5e-218) {
tmp = x * (y * z);
} else if (t <= 1.2e-128) {
tmp = i * (a * b);
} else if (t <= 6.1e-5) {
tmp = c * (z * -b);
} else if (t <= 1.15e+108) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * (t * j) tmp = 0 if t <= -4e+45: tmp = t_1 elif t <= 5e-218: tmp = x * (y * z) elif t <= 1.2e-128: tmp = i * (a * b) elif t <= 6.1e-5: tmp = c * (z * -b) elif t <= 1.15e+108: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(t * j)) tmp = 0.0 if (t <= -4e+45) tmp = t_1; elseif (t <= 5e-218) tmp = Float64(x * Float64(y * z)); elseif (t <= 1.2e-128) tmp = Float64(i * Float64(a * b)); elseif (t <= 6.1e-5) tmp = Float64(c * Float64(z * Float64(-b))); elseif (t <= 1.15e+108) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * (t * j); tmp = 0.0; if (t <= -4e+45) tmp = t_1; elseif (t <= 5e-218) tmp = x * (y * z); elseif (t <= 1.2e-128) tmp = i * (a * b); elseif (t <= 6.1e-5) tmp = c * (z * -b); elseif (t <= 1.15e+108) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -4e+45], t$95$1, If[LessEqual[t, 5e-218], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e-128], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 6.1e-5], N[(c * N[(z * (-b)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.15e+108], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right)\\
\mathbf{if}\;t \leq -4 \cdot 10^{+45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-218}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{-128}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;t \leq 6.1 \cdot 10^{-5}:\\
\;\;\;\;c \cdot \left(z \cdot \left(-b\right)\right)\\
\mathbf{elif}\;t \leq 1.15 \cdot 10^{+108}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -3.9999999999999997e45 or 1.1499999999999999e108 < t Initial program 73.7%
Taylor expanded in x around inf 67.7%
associate--r+67.7%
sub-neg67.7%
mul-1-neg67.7%
+-commutative67.7%
associate-+r+67.7%
associate-+r-67.7%
+-commutative67.7%
div-sub67.8%
Simplified67.8%
Taylor expanded in c around inf 53.0%
associate-*r*52.9%
associate-/l*50.6%
associate-/l*47.3%
Simplified47.3%
Taylor expanded in z around inf 54.0%
+-commutative54.0%
mul-1-neg54.0%
unsub-neg54.0%
associate-*r*50.9%
*-commutative50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in z around 0 51.8%
if -3.9999999999999997e45 < t < 5.00000000000000041e-218Initial program 80.9%
Taylor expanded in y around inf 46.2%
+-commutative46.2%
mul-1-neg46.2%
unsub-neg46.2%
Simplified46.2%
Taylor expanded in x around inf 31.9%
if 5.00000000000000041e-218 < t < 1.1999999999999999e-128Initial program 77.7%
Taylor expanded in b around inf 51.1%
*-commutative51.1%
Simplified51.1%
Taylor expanded in a around inf 41.0%
associate-*r*49.2%
*-commutative49.2%
Simplified49.2%
if 1.1999999999999999e-128 < t < 6.09999999999999987e-5Initial program 82.2%
Taylor expanded in t around 0 56.3%
*-commutative56.3%
associate-*r*60.4%
associate-*r*56.0%
associate-*r*56.0%
distribute-rgt-in56.0%
+-commutative56.0%
mul-1-neg56.0%
unsub-neg56.0%
*-commutative56.0%
Simplified56.0%
Taylor expanded in c around inf 24.8%
mul-1-neg24.8%
associate-*r*20.8%
*-commutative20.8%
associate-*r*29.0%
distribute-rgt-neg-out29.0%
*-commutative29.0%
distribute-rgt-neg-in29.0%
Simplified29.0%
if 6.09999999999999987e-5 < t < 1.1499999999999999e108Initial program 74.5%
Taylor expanded in b around inf 32.5%
*-commutative32.5%
Simplified32.5%
Taylor expanded in a around inf 29.0%
Final simplification40.0%
(FPCore (x y z t a b c i j)
:precision binary64
(if (or (<= y -1.16e+167)
(and (not (<= y -4.8e+70)) (or (<= y -4e-24) (not (<= y 1.6e+103)))))
(* i (* y (- j)))
(* 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 tmp;
if ((y <= -1.16e+167) || (!(y <= -4.8e+70) && ((y <= -4e-24) || !(y <= 1.6e+103)))) {
tmp = i * (y * -j);
} else {
tmp = 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) :: tmp
if ((y <= (-1.16d+167)) .or. (.not. (y <= (-4.8d+70))) .and. (y <= (-4d-24)) .or. (.not. (y <= 1.6d+103))) then
tmp = i * (y * -j)
else
tmp = 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 tmp;
if ((y <= -1.16e+167) || (!(y <= -4.8e+70) && ((y <= -4e-24) || !(y <= 1.6e+103)))) {
tmp = i * (y * -j);
} else {
tmp = b * ((a * i) - (z * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (y <= -1.16e+167) or (not (y <= -4.8e+70) and ((y <= -4e-24) or not (y <= 1.6e+103))): tmp = i * (y * -j) else: tmp = b * ((a * i) - (z * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((y <= -1.16e+167) || (!(y <= -4.8e+70) && ((y <= -4e-24) || !(y <= 1.6e+103)))) tmp = Float64(i * Float64(y * Float64(-j))); else tmp = 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) tmp = 0.0; if ((y <= -1.16e+167) || (~((y <= -4.8e+70)) && ((y <= -4e-24) || ~((y <= 1.6e+103))))) tmp = i * (y * -j); else tmp = b * ((a * i) - (z * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[y, -1.16e+167], And[N[Not[LessEqual[y, -4.8e+70]], $MachinePrecision], Or[LessEqual[y, -4e-24], N[Not[LessEqual[y, 1.6e+103]], $MachinePrecision]]]], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.16 \cdot 10^{+167} \lor \neg \left(y \leq -4.8 \cdot 10^{+70}\right) \land \left(y \leq -4 \cdot 10^{-24} \lor \neg \left(y \leq 1.6 \cdot 10^{+103}\right)\right):\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\end{array}
\end{array}
if y < -1.1600000000000001e167 or -4.79999999999999974e70 < y < -3.99999999999999969e-24 or 1.59999999999999996e103 < y Initial program 70.2%
Taylor expanded in t around 0 63.9%
*-commutative63.9%
associate-*r*67.8%
associate-*r*69.0%
associate-*r*69.0%
distribute-rgt-in71.2%
+-commutative71.2%
mul-1-neg71.2%
unsub-neg71.2%
*-commutative71.2%
Simplified71.2%
Taylor expanded in j around inf 42.8%
mul-1-neg42.8%
*-commutative42.8%
distribute-rgt-neg-out42.8%
distribute-rgt-neg-in42.8%
Simplified42.8%
if -1.1600000000000001e167 < y < -4.79999999999999974e70 or -3.99999999999999969e-24 < y < 1.59999999999999996e103Initial program 82.0%
Taylor expanded in b around inf 45.6%
*-commutative45.6%
Simplified45.6%
Final simplification44.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= i -5.2e+24)
(* i (* y (- j)))
(if (<= i 3.2e-60)
t_1
(if (<= i 2.1e-48)
(* z (* x y))
(if (<= i 1.25e+71) 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 = c * ((t * j) - (z * b));
double tmp;
if (i <= -5.2e+24) {
tmp = i * (y * -j);
} else if (i <= 3.2e-60) {
tmp = t_1;
} else if (i <= 2.1e-48) {
tmp = z * (x * y);
} else if (i <= 1.25e+71) {
tmp = t_1;
} else {
tmp = 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 = c * ((t * j) - (z * b))
if (i <= (-5.2d+24)) then
tmp = i * (y * -j)
else if (i <= 3.2d-60) then
tmp = t_1
else if (i <= 2.1d-48) then
tmp = z * (x * y)
else if (i <= 1.25d+71) then
tmp = t_1
else
tmp = 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 = c * ((t * j) - (z * b));
double tmp;
if (i <= -5.2e+24) {
tmp = i * (y * -j);
} else if (i <= 3.2e-60) {
tmp = t_1;
} else if (i <= 2.1e-48) {
tmp = z * (x * y);
} else if (i <= 1.25e+71) {
tmp = t_1;
} else {
tmp = b * ((a * i) - (z * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((t * j) - (z * b)) tmp = 0 if i <= -5.2e+24: tmp = i * (y * -j) elif i <= 3.2e-60: tmp = t_1 elif i <= 2.1e-48: tmp = z * (x * y) elif i <= 1.25e+71: tmp = t_1 else: tmp = b * ((a * i) - (z * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (i <= -5.2e+24) tmp = Float64(i * Float64(y * Float64(-j))); elseif (i <= 3.2e-60) tmp = t_1; elseif (i <= 2.1e-48) tmp = Float64(z * Float64(x * y)); elseif (i <= 1.25e+71) tmp = t_1; else tmp = 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 = c * ((t * j) - (z * b)); tmp = 0.0; if (i <= -5.2e+24) tmp = i * (y * -j); elseif (i <= 3.2e-60) tmp = t_1; elseif (i <= 2.1e-48) tmp = z * (x * y); elseif (i <= 1.25e+71) tmp = t_1; else tmp = 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[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -5.2e+24], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.2e-60], t$95$1, If[LessEqual[i, 2.1e-48], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.25e+71], t$95$1, N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;i \leq -5.2 \cdot 10^{+24}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{elif}\;i \leq 3.2 \cdot 10^{-60}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 2.1 \cdot 10^{-48}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;i \leq 1.25 \cdot 10^{+71}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\end{array}
\end{array}
if i < -5.1999999999999997e24Initial program 67.5%
Taylor expanded in t around 0 69.6%
*-commutative69.6%
associate-*r*67.8%
associate-*r*62.6%
associate-*r*62.6%
distribute-rgt-in64.5%
+-commutative64.5%
mul-1-neg64.5%
unsub-neg64.5%
*-commutative64.5%
Simplified64.5%
Taylor expanded in j around inf 40.4%
mul-1-neg40.4%
*-commutative40.4%
distribute-rgt-neg-out40.4%
distribute-rgt-neg-in40.4%
Simplified40.4%
if -5.1999999999999997e24 < i < 3.2000000000000001e-60 or 2.09999999999999989e-48 < i < 1.24999999999999993e71Initial program 82.6%
Taylor expanded in c around inf 50.1%
*-commutative50.1%
*-commutative50.1%
Simplified50.1%
if 3.2000000000000001e-60 < i < 2.09999999999999989e-48Initial program 82.6%
Taylor expanded in t around 0 82.6%
*-commutative82.6%
associate-*r*67.1%
associate-*r*67.1%
associate-*r*67.1%
distribute-rgt-in67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
Taylor expanded in x around inf 84.0%
associate-*r*84.5%
*-commutative84.5%
Simplified84.5%
if 1.24999999999999993e71 < i Initial program 71.7%
Taylor expanded in b around inf 49.8%
*-commutative49.8%
Simplified49.8%
Final simplification48.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))) (t_2 (* j (- (* t c) (* y i)))))
(if (<= j -7.2e-128)
t_2
(if (<= j 1.3e-276)
t_1
(if (<= j 6.8e-214) (* z (* x y)) (if (<= j 2e-35) 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));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -7.2e-128) {
tmp = t_2;
} else if (j <= 1.3e-276) {
tmp = t_1;
} else if (j <= 6.8e-214) {
tmp = z * (x * y);
} else if (j <= 2e-35) {
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))
t_2 = j * ((t * c) - (y * i))
if (j <= (-7.2d-128)) then
tmp = t_2
else if (j <= 1.3d-276) then
tmp = t_1
else if (j <= 6.8d-214) then
tmp = z * (x * y)
else if (j <= 2d-35) 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));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (j <= -7.2e-128) {
tmp = t_2;
} else if (j <= 1.3e-276) {
tmp = t_1;
} else if (j <= 6.8e-214) {
tmp = z * (x * y);
} else if (j <= 2e-35) {
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)) t_2 = j * ((t * c) - (y * i)) tmp = 0 if j <= -7.2e-128: tmp = t_2 elif j <= 1.3e-276: tmp = t_1 elif j <= 6.8e-214: tmp = z * (x * y) elif j <= 2e-35: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -7.2e-128) tmp = t_2; elseif (j <= 1.3e-276) tmp = t_1; elseif (j <= 6.8e-214) tmp = Float64(z * Float64(x * y)); elseif (j <= 2e-35) 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)); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (j <= -7.2e-128) tmp = t_2; elseif (j <= 1.3e-276) tmp = t_1; elseif (j <= 6.8e-214) tmp = z * (x * y); elseif (j <= 2e-35) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -7.2e-128], t$95$2, If[LessEqual[j, 1.3e-276], t$95$1, If[LessEqual[j, 6.8e-214], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2e-35], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -7.2 \cdot 10^{-128}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq 1.3 \cdot 10^{-276}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 6.8 \cdot 10^{-214}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;j \leq 2 \cdot 10^{-35}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -7.20000000000000049e-128 or 2.00000000000000002e-35 < j Initial program 79.5%
Taylor expanded in j around inf 59.2%
if -7.20000000000000049e-128 < j < 1.29999999999999992e-276 or 6.7999999999999998e-214 < j < 2.00000000000000002e-35Initial program 77.6%
Taylor expanded in b around inf 54.1%
*-commutative54.1%
Simplified54.1%
if 1.29999999999999992e-276 < j < 6.7999999999999998e-214Initial program 58.4%
Taylor expanded in t around 0 57.1%
*-commutative57.1%
associate-*r*51.7%
associate-*r*51.7%
associate-*r*51.7%
distribute-rgt-in51.7%
+-commutative51.7%
mul-1-neg51.7%
unsub-neg51.7%
*-commutative51.7%
Simplified51.7%
Taylor expanded in x around inf 51.7%
associate-*r*51.8%
*-commutative51.8%
Simplified51.8%
Final simplification57.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -4.2e+24)
t_1
(if (<= x -2.65e-95)
(* c (- (* t j) (* z b)))
(if (<= x -2.5e-167)
(* b (- (* a i) (* z c)))
(if (<= x 1.3e+48) (* j (- (* t c) (* y i))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -4.2e+24) {
tmp = t_1;
} else if (x <= -2.65e-95) {
tmp = c * ((t * j) - (z * b));
} else if (x <= -2.5e-167) {
tmp = b * ((a * i) - (z * c));
} else if (x <= 1.3e+48) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if (x <= (-4.2d+24)) then
tmp = t_1
else if (x <= (-2.65d-95)) then
tmp = c * ((t * j) - (z * b))
else if (x <= (-2.5d-167)) then
tmp = b * ((a * i) - (z * c))
else if (x <= 1.3d+48) then
tmp = j * ((t * c) - (y * i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -4.2e+24) {
tmp = t_1;
} else if (x <= -2.65e-95) {
tmp = c * ((t * j) - (z * b));
} else if (x <= -2.5e-167) {
tmp = b * ((a * i) - (z * c));
} else if (x <= 1.3e+48) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if x <= -4.2e+24: tmp = t_1 elif x <= -2.65e-95: tmp = c * ((t * j) - (z * b)) elif x <= -2.5e-167: tmp = b * ((a * i) - (z * c)) elif x <= 1.3e+48: tmp = j * ((t * c) - (y * i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -4.2e+24) tmp = t_1; elseif (x <= -2.65e-95) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (x <= -2.5e-167) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (x <= 1.3e+48) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -4.2e+24) tmp = t_1; elseif (x <= -2.65e-95) tmp = c * ((t * j) - (z * b)); elseif (x <= -2.5e-167) tmp = b * ((a * i) - (z * c)); elseif (x <= 1.3e+48) tmp = j * ((t * c) - (y * i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4.2e+24], t$95$1, If[LessEqual[x, -2.65e-95], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.5e-167], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.3e+48], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -4.2 \cdot 10^{+24}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -2.65 \cdot 10^{-95}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;x \leq -2.5 \cdot 10^{-167}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;x \leq 1.3 \cdot 10^{+48}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -4.2000000000000003e24 or 1.29999999999999998e48 < x Initial program 79.8%
Taylor expanded in b around 0 71.4%
Taylor expanded in j around 0 64.8%
sub-neg64.8%
*-commutative64.8%
sub-neg64.8%
Simplified64.8%
if -4.2000000000000003e24 < x < -2.6499999999999999e-95Initial program 77.2%
Taylor expanded in c around inf 52.6%
*-commutative52.6%
*-commutative52.6%
Simplified52.6%
if -2.6499999999999999e-95 < x < -2.5000000000000001e-167Initial program 83.3%
Taylor expanded in b around inf 76.0%
*-commutative76.0%
Simplified76.0%
if -2.5000000000000001e-167 < x < 1.29999999999999998e48Initial program 74.6%
Taylor expanded in j around inf 55.2%
Final simplification60.2%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= j -3e-109) (not (<= j 2.5e-34))) (* c (* t j)) (* 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 ((j <= -3e-109) || !(j <= 2.5e-34)) {
tmp = c * (t * j);
} 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 ((j <= (-3d-109)) .or. (.not. (j <= 2.5d-34))) then
tmp = c * (t * j)
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 ((j <= -3e-109) || !(j <= 2.5e-34)) {
tmp = c * (t * j);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (j <= -3e-109) or not (j <= 2.5e-34): tmp = c * (t * j) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((j <= -3e-109) || !(j <= 2.5e-34)) tmp = Float64(c * Float64(t * j)); 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 ((j <= -3e-109) || ~((j <= 2.5e-34))) tmp = c * (t * j); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[j, -3e-109], N[Not[LessEqual[j, 2.5e-34]], $MachinePrecision]], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -3 \cdot 10^{-109} \lor \neg \left(j \leq 2.5 \cdot 10^{-34}\right):\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if j < -3.00000000000000021e-109 or 2.5000000000000001e-34 < j Initial program 79.5%
Taylor expanded in x around inf 72.5%
associate--r+72.5%
sub-neg72.5%
mul-1-neg72.5%
+-commutative72.5%
associate-+r+72.5%
associate-+r-72.5%
+-commutative72.5%
div-sub75.2%
Simplified75.2%
Taylor expanded in c around inf 46.7%
associate-*r*43.6%
associate-/l*41.2%
associate-/l*38.2%
Simplified38.2%
Taylor expanded in z around inf 40.1%
+-commutative40.1%
mul-1-neg40.1%
unsub-neg40.1%
associate-*r*37.1%
*-commutative37.1%
*-commutative37.1%
Simplified37.1%
Taylor expanded in z around 0 34.5%
if -3.00000000000000021e-109 < j < 2.5000000000000001e-34Initial program 74.3%
Taylor expanded in b around inf 47.1%
*-commutative47.1%
Simplified47.1%
Taylor expanded in a around inf 30.8%
*-commutative30.8%
Simplified30.8%
Final simplification33.2%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= j -1.46e-111) (* j (* t c)) (if (<= j 8.5e-35) (* b (* a i)) (* c (* t j)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -1.46e-111) {
tmp = j * (t * c);
} else if (j <= 8.5e-35) {
tmp = b * (a * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (j <= (-1.46d-111)) then
tmp = j * (t * c)
else if (j <= 8.5d-35) then
tmp = b * (a * i)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -1.46e-111) {
tmp = j * (t * c);
} else if (j <= 8.5e-35) {
tmp = b * (a * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if j <= -1.46e-111: tmp = j * (t * c) elif j <= 8.5e-35: tmp = b * (a * i) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -1.46e-111) tmp = Float64(j * Float64(t * c)); elseif (j <= 8.5e-35) tmp = Float64(b * Float64(a * i)); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (j <= -1.46e-111) tmp = j * (t * c); elseif (j <= 8.5e-35) tmp = b * (a * i); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -1.46e-111], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 8.5e-35], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.46 \cdot 10^{-111}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;j \leq 8.5 \cdot 10^{-35}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if j < -1.46e-111Initial program 81.2%
Taylor expanded in x around inf 74.1%
associate--r+74.1%
sub-neg74.1%
mul-1-neg74.1%
+-commutative74.1%
associate-+r+74.1%
associate-+r-74.1%
+-commutative74.1%
div-sub75.4%
Simplified75.4%
Taylor expanded in c around inf 42.0%
associate-*r*38.6%
associate-/l*37.6%
associate-/l*33.3%
Simplified33.3%
Taylor expanded in z around inf 32.3%
+-commutative32.3%
mul-1-neg32.3%
unsub-neg32.3%
associate-*r*32.3%
*-commutative32.3%
*-commutative32.3%
Simplified32.3%
Taylor expanded in z around 0 31.0%
*-commutative31.0%
associate-*r*31.6%
*-commutative31.6%
Simplified31.6%
if -1.46e-111 < j < 8.5000000000000001e-35Initial program 74.8%
Taylor expanded in b around inf 48.0%
*-commutative48.0%
Simplified48.0%
Taylor expanded in a around inf 31.4%
*-commutative31.4%
Simplified31.4%
if 8.5000000000000001e-35 < j Initial program 76.7%
Taylor expanded in x around inf 70.1%
associate--r+70.1%
sub-neg70.1%
mul-1-neg70.1%
+-commutative70.1%
associate-+r+70.1%
associate-+r-70.1%
+-commutative70.1%
div-sub74.2%
Simplified74.2%
Taylor expanded in c around inf 51.5%
associate-*r*48.7%
associate-/l*44.6%
associate-/l*43.3%
Simplified43.3%
Taylor expanded in z around inf 48.9%
+-commutative48.9%
mul-1-neg48.9%
unsub-neg48.9%
associate-*r*43.7%
*-commutative43.7%
*-commutative43.7%
Simplified43.7%
Taylor expanded in z around 0 38.0%
Final simplification33.4%
(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 77.6%
Taylor expanded in b around inf 34.8%
*-commutative34.8%
Simplified34.8%
Taylor expanded in a around inf 19.1%
Final simplification19.1%
(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 2024078
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(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)))))