
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c))))
(t_2
(* t (+ (* c j) (- (/ (+ (* y (- (* x z) (* i j))) t_1) t) (* x a)))))
(t_3 (+ (- t_1 (* x (- (* t a) (* y z)))) (* j (- (* t c) (* y i))))))
(if (<= t_3 (- INFINITY))
t_2
(if (<= t_3 1e+305)
t_3
(if (<= t_3 INFINITY) t_2 (* y (* x (- z (* i (/ j x))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = t * ((c * j) + ((((y * ((x * z) - (i * j))) + t_1) / t) - (x * a)));
double t_3 = (t_1 - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = t_2;
} else if (t_3 <= 1e+305) {
tmp = t_3;
} else if (t_3 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
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 = b * ((a * i) - (z * c));
double t_2 = t * ((c * j) + ((((y * ((x * z) - (i * j))) + t_1) / t) - (x * a)));
double t_3 = (t_1 - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_3 <= -Double.POSITIVE_INFINITY) {
tmp = t_2;
} else if (t_3 <= 1e+305) {
tmp = t_3;
} else if (t_3 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) t_2 = t * ((c * j) + ((((y * ((x * z) - (i * j))) + t_1) / t) - (x * a))) t_3 = (t_1 - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_3 <= -math.inf: tmp = t_2 elif t_3 <= 1e+305: tmp = t_3 elif t_3 <= math.inf: tmp = t_2 else: tmp = y * (x * (z - (i * (j / x)))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(t * Float64(Float64(c * j) + Float64(Float64(Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + t_1) / t) - Float64(x * a)))) t_3 = Float64(Float64(t_1 - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = t_2; elseif (t_3 <= 1e+305) tmp = t_3; elseif (t_3 <= Inf) tmp = t_2; else tmp = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); t_2 = t * ((c * j) + ((((y * ((x * z) - (i * j))) + t_1) / t) - (x * a))); t_3 = (t_1 - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_3 <= -Inf) tmp = t_2; elseif (t_3 <= 1e+305) tmp = t_3; elseif (t_3 <= Inf) tmp = t_2; else tmp = y * (x * (z - (i * (j / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t * N[(N[(c * j), $MachinePrecision] + N[(N[(N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] / t), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(t$95$1 - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], t$95$2, If[LessEqual[t$95$3, 1e+305], t$95$3, If[LessEqual[t$95$3, Infinity], t$95$2, N[(y * N[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $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 \left(c \cdot j + \left(\frac{y \cdot \left(x \cdot z - i \cdot j\right) + t\_1}{t} - x \cdot a\right)\right)\\
t_3 := \left(t\_1 - x \cdot \left(t \cdot a - y \cdot z\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 10^{+305}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < -inf.0 or 9.9999999999999994e304 < (+.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 83.5%
Taylor expanded in t around -inf 88.6%
Simplified90.7%
if -inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < 9.9999999999999994e304Initial program 99.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 y around inf 55.6%
+-commutative55.6%
mul-1-neg55.6%
unsub-neg55.6%
Simplified55.6%
Taylor expanded in x around inf 59.6%
mul-1-neg59.6%
unsub-neg59.6%
associate-/l*59.5%
Simplified59.5%
Final simplification87.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* b (- (* a i) (* z c))) (* x (- (* t a) (* y z))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* y (* x (- z (* i (/ j x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
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 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = y * (x * (z - (i * (j / x)))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = y * (x * (z - (i * (j / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(y * N[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot \left(a \cdot i - z \cdot c\right) - x \cdot \left(t \cdot a - y \cdot z\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 89.9%
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 y around inf 55.6%
+-commutative55.6%
mul-1-neg55.6%
unsub-neg55.6%
Simplified55.6%
Taylor expanded in x around inf 59.6%
mul-1-neg59.6%
unsub-neg59.6%
associate-/l*59.5%
Simplified59.5%
Final simplification84.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t)))))
(if (<= z -4e+178)
(* x (- (* y z) (* t a)))
(if (<= z -1.15e-30)
(+ (* t (* c j)) (* b (- (* a i) (* z c))))
(if (<= z -1.9e-115)
t_1
(if (<= z -1.85e-229)
(* i (- (* a b) (* y j)))
(if (<= z 2.8e-236)
(* t (+ (* c j) (- (* a (/ (* b i) t)) (* x a))))
(if (<= z 1.75e-130)
t_1
(if (<= z 6e+106)
(- (* t (- (* c j) (* x a))) (* b (* z c)))
(* z (- (* x y) (* b c))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double tmp;
if (z <= -4e+178) {
tmp = x * ((y * z) - (t * a));
} else if (z <= -1.15e-30) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else if (z <= -1.9e-115) {
tmp = t_1;
} else if (z <= -1.85e-229) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 2.8e-236) {
tmp = t * ((c * j) + ((a * ((b * i) / t)) - (x * a)));
} else if (z <= 1.75e-130) {
tmp = t_1;
} else if (z <= 6e+106) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else {
tmp = z * ((x * y) - (b * 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 = a * ((b * i) - (x * t))
if (z <= (-4d+178)) then
tmp = x * ((y * z) - (t * a))
else if (z <= (-1.15d-30)) then
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)))
else if (z <= (-1.9d-115)) then
tmp = t_1
else if (z <= (-1.85d-229)) then
tmp = i * ((a * b) - (y * j))
else if (z <= 2.8d-236) then
tmp = t * ((c * j) + ((a * ((b * i) / t)) - (x * a)))
else if (z <= 1.75d-130) then
tmp = t_1
else if (z <= 6d+106) then
tmp = (t * ((c * j) - (x * a))) - (b * (z * c))
else
tmp = z * ((x * y) - (b * 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 = a * ((b * i) - (x * t));
double tmp;
if (z <= -4e+178) {
tmp = x * ((y * z) - (t * a));
} else if (z <= -1.15e-30) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else if (z <= -1.9e-115) {
tmp = t_1;
} else if (z <= -1.85e-229) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 2.8e-236) {
tmp = t * ((c * j) + ((a * ((b * i) / t)) - (x * a)));
} else if (z <= 1.75e-130) {
tmp = t_1;
} else if (z <= 6e+106) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) tmp = 0 if z <= -4e+178: tmp = x * ((y * z) - (t * a)) elif z <= -1.15e-30: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) elif z <= -1.9e-115: tmp = t_1 elif z <= -1.85e-229: tmp = i * ((a * b) - (y * j)) elif z <= 2.8e-236: tmp = t * ((c * j) + ((a * ((b * i) / t)) - (x * a))) elif z <= 1.75e-130: tmp = t_1 elif z <= 6e+106: tmp = (t * ((c * j) - (x * a))) - (b * (z * c)) else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) tmp = 0.0 if (z <= -4e+178) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (z <= -1.15e-30) tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (z <= -1.9e-115) tmp = t_1; elseif (z <= -1.85e-229) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (z <= 2.8e-236) tmp = Float64(t * Float64(Float64(c * j) + Float64(Float64(a * Float64(Float64(b * i) / t)) - Float64(x * a)))); elseif (z <= 1.75e-130) tmp = t_1; elseif (z <= 6e+106) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) - Float64(b * Float64(z * c))); else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); tmp = 0.0; if (z <= -4e+178) tmp = x * ((y * z) - (t * a)); elseif (z <= -1.15e-30) tmp = (t * (c * j)) + (b * ((a * i) - (z * c))); elseif (z <= -1.9e-115) tmp = t_1; elseif (z <= -1.85e-229) tmp = i * ((a * b) - (y * j)); elseif (z <= 2.8e-236) tmp = t * ((c * j) + ((a * ((b * i) / t)) - (x * a))); elseif (z <= 1.75e-130) tmp = t_1; elseif (z <= 6e+106) tmp = (t * ((c * j) - (x * a))) - (b * (z * c)); else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4e+178], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.15e-30], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.9e-115], t$95$1, If[LessEqual[z, -1.85e-229], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.8e-236], N[(t * N[(N[(c * j), $MachinePrecision] + N[(N[(a * N[(N[(b * i), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.75e-130], t$95$1, If[LessEqual[z, 6e+106], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{if}\;z \leq -4 \cdot 10^{+178}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{-30}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{-115}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.85 \cdot 10^{-229}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;z \leq 2.8 \cdot 10^{-236}:\\
\;\;\;\;t \cdot \left(c \cdot j + \left(a \cdot \frac{b \cdot i}{t} - x \cdot a\right)\right)\\
\mathbf{elif}\;z \leq 1.75 \cdot 10^{-130}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6 \cdot 10^{+106}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) - b \cdot \left(z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if z < -4.0000000000000002e178Initial program 66.9%
+-commutative66.9%
fma-define66.9%
*-commutative66.9%
*-commutative66.9%
cancel-sign-sub-inv66.9%
cancel-sign-sub66.9%
sub-neg66.9%
sub-neg66.9%
*-commutative66.9%
fma-neg66.9%
*-commutative66.9%
distribute-rgt-neg-out66.9%
remove-double-neg66.9%
*-commutative66.9%
*-commutative66.9%
Simplified66.9%
Taylor expanded in x around inf 81.8%
if -4.0000000000000002e178 < z < -1.14999999999999992e-30Initial program 71.4%
Taylor expanded in y around 0 75.8%
+-commutative75.8%
*-commutative75.8%
associate-*r*75.8%
*-commutative75.8%
associate-*l*75.7%
mul-1-neg75.7%
associate-*r*71.6%
*-commutative71.6%
associate-*l*75.8%
distribute-rgt-neg-in75.8%
mul-1-neg75.8%
distribute-lft-in75.8%
mul-1-neg75.8%
unsub-neg75.8%
*-commutative75.8%
*-commutative75.8%
*-commutative75.8%
Simplified75.8%
Taylor expanded in j around inf 82.1%
associate-*r*82.0%
*-commutative82.0%
*-commutative82.0%
*-commutative82.0%
Simplified82.0%
if -1.14999999999999992e-30 < z < -1.89999999999999996e-115 or 2.79999999999999986e-236 < z < 1.75e-130Initial program 77.6%
Taylor expanded in y around 0 61.9%
+-commutative61.9%
*-commutative61.9%
associate-*r*61.9%
*-commutative61.9%
associate-*l*61.0%
mul-1-neg61.0%
associate-*r*53.8%
*-commutative53.8%
associate-*l*53.8%
distribute-rgt-neg-in53.8%
mul-1-neg53.8%
distribute-lft-in56.3%
mul-1-neg56.3%
unsub-neg56.3%
*-commutative56.3%
*-commutative56.3%
*-commutative56.3%
Simplified56.3%
Taylor expanded in c around 0 59.8%
associate-*r*59.8%
neg-mul-159.8%
cancel-sign-sub59.8%
mul-1-neg59.8%
distribute-rgt-neg-in59.8%
mul-1-neg59.8%
distribute-lft-in62.3%
+-commutative62.3%
mul-1-neg62.3%
unsub-neg62.3%
Simplified62.3%
if -1.89999999999999996e-115 < z < -1.8499999999999999e-229Initial program 82.3%
Taylor expanded in i around inf 77.8%
distribute-lft-out--77.8%
*-commutative77.8%
Simplified77.8%
if -1.8499999999999999e-229 < z < 2.79999999999999986e-236Initial program 77.9%
Taylor expanded in t around -inf 81.1%
Simplified77.9%
Taylor expanded in a around inf 77.9%
associate-/l*77.9%
Simplified77.9%
if 1.75e-130 < z < 6.0000000000000001e106Initial program 73.3%
Taylor expanded in y around 0 63.8%
+-commutative63.8%
*-commutative63.8%
associate-*r*61.8%
*-commutative61.8%
associate-*l*63.9%
mul-1-neg63.9%
associate-*r*66.0%
*-commutative66.0%
associate-*l*68.0%
distribute-rgt-neg-in68.0%
mul-1-neg68.0%
distribute-lft-in70.1%
mul-1-neg70.1%
unsub-neg70.1%
*-commutative70.1%
*-commutative70.1%
*-commutative70.1%
Simplified70.1%
Taylor expanded in z around inf 66.1%
if 6.0000000000000001e106 < z Initial program 63.0%
Taylor expanded in z around inf 88.0%
*-commutative88.0%
Simplified88.0%
Final simplification76.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t))))
(t_2 (* c (- (* t j) (* z b))))
(t_3 (* y (- (* x z) (* i j)))))
(if (<= y -4.3e-48)
t_3
(if (<= y -1.18e-206)
t_2
(if (<= y -5.6e-272)
t_1
(if (<= y -6.5e-304)
t_2
(if (<= y 8.5e-279)
t_1
(if (<= y 3.3e-220) t_2 (if (<= y 1.6e+64) t_1 t_3)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double t_2 = c * ((t * j) - (z * b));
double t_3 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.3e-48) {
tmp = t_3;
} else if (y <= -1.18e-206) {
tmp = t_2;
} else if (y <= -5.6e-272) {
tmp = t_1;
} else if (y <= -6.5e-304) {
tmp = t_2;
} else if (y <= 8.5e-279) {
tmp = t_1;
} else if (y <= 3.3e-220) {
tmp = t_2;
} else if (y <= 1.6e+64) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = a * ((b * i) - (x * t))
t_2 = c * ((t * j) - (z * b))
t_3 = y * ((x * z) - (i * j))
if (y <= (-4.3d-48)) then
tmp = t_3
else if (y <= (-1.18d-206)) then
tmp = t_2
else if (y <= (-5.6d-272)) then
tmp = t_1
else if (y <= (-6.5d-304)) then
tmp = t_2
else if (y <= 8.5d-279) then
tmp = t_1
else if (y <= 3.3d-220) then
tmp = t_2
else if (y <= 1.6d+64) then
tmp = t_1
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double t_2 = c * ((t * j) - (z * b));
double t_3 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.3e-48) {
tmp = t_3;
} else if (y <= -1.18e-206) {
tmp = t_2;
} else if (y <= -5.6e-272) {
tmp = t_1;
} else if (y <= -6.5e-304) {
tmp = t_2;
} else if (y <= 8.5e-279) {
tmp = t_1;
} else if (y <= 3.3e-220) {
tmp = t_2;
} else if (y <= 1.6e+64) {
tmp = t_1;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) t_2 = c * ((t * j) - (z * b)) t_3 = y * ((x * z) - (i * j)) tmp = 0 if y <= -4.3e-48: tmp = t_3 elif y <= -1.18e-206: tmp = t_2 elif y <= -5.6e-272: tmp = t_1 elif y <= -6.5e-304: tmp = t_2 elif y <= 8.5e-279: tmp = t_1 elif y <= 3.3e-220: tmp = t_2 elif y <= 1.6e+64: tmp = t_1 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) t_2 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) t_3 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -4.3e-48) tmp = t_3; elseif (y <= -1.18e-206) tmp = t_2; elseif (y <= -5.6e-272) tmp = t_1; elseif (y <= -6.5e-304) tmp = t_2; elseif (y <= 8.5e-279) tmp = t_1; elseif (y <= 3.3e-220) tmp = t_2; elseif (y <= 1.6e+64) tmp = t_1; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); t_2 = c * ((t * j) - (z * b)); t_3 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -4.3e-48) tmp = t_3; elseif (y <= -1.18e-206) tmp = t_2; elseif (y <= -5.6e-272) tmp = t_1; elseif (y <= -6.5e-304) tmp = t_2; elseif (y <= 8.5e-279) tmp = t_1; elseif (y <= 3.3e-220) tmp = t_2; elseif (y <= 1.6e+64) tmp = t_1; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.3e-48], t$95$3, If[LessEqual[y, -1.18e-206], t$95$2, If[LessEqual[y, -5.6e-272], t$95$1, If[LessEqual[y, -6.5e-304], t$95$2, If[LessEqual[y, 8.5e-279], t$95$1, If[LessEqual[y, 3.3e-220], t$95$2, If[LessEqual[y, 1.6e+64], t$95$1, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
t_2 := c \cdot \left(t \cdot j - z \cdot b\right)\\
t_3 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -4.3 \cdot 10^{-48}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;y \leq -1.18 \cdot 10^{-206}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -5.6 \cdot 10^{-272}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6.5 \cdot 10^{-304}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 8.5 \cdot 10^{-279}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{-220}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq 1.6 \cdot 10^{+64}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if y < -4.3e-48 or 1.60000000000000009e64 < y Initial program 57.4%
Taylor expanded in y around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified71.1%
if -4.3e-48 < y < -1.17999999999999994e-206 or -5.59999999999999987e-272 < y < -6.50000000000000011e-304 or 8.5000000000000002e-279 < y < 3.29999999999999999e-220Initial program 83.2%
Taylor expanded in c around inf 78.0%
*-commutative78.0%
*-commutative78.0%
Simplified78.0%
if -1.17999999999999994e-206 < y < -5.59999999999999987e-272 or -6.50000000000000011e-304 < y < 8.5000000000000002e-279 or 3.29999999999999999e-220 < y < 1.60000000000000009e64Initial program 86.7%
Taylor expanded in y around 0 81.3%
+-commutative81.3%
*-commutative81.3%
associate-*r*81.2%
*-commutative81.2%
associate-*l*81.2%
mul-1-neg81.2%
associate-*r*76.3%
*-commutative76.3%
associate-*l*79.3%
distribute-rgt-neg-in79.3%
mul-1-neg79.3%
distribute-lft-in81.4%
mul-1-neg81.4%
unsub-neg81.4%
*-commutative81.4%
*-commutative81.4%
*-commutative81.4%
Simplified81.4%
Taylor expanded in c around 0 59.4%
associate-*r*59.4%
neg-mul-159.4%
cancel-sign-sub59.4%
mul-1-neg59.4%
distribute-rgt-neg-in59.4%
mul-1-neg59.4%
distribute-lft-in59.4%
+-commutative59.4%
mul-1-neg59.4%
unsub-neg59.4%
Simplified59.4%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* j (- (* t c) (* y i))) (* x (- (* t a) (* y z))))))
(if (<= b -2.6e+110)
(+ (* t (* c j)) (* b (- (* a i) (* z c))))
(if (<= b -3.4e+34)
t_1
(if (<= b -5.3e-17)
(- (* t (- (* c j) (* x a))) (* b (* z c)))
(if (<= b -1.7e-70)
(* y (- (* x z) (* i j)))
(if (<= b 9.5e-21)
t_1
(if (<= b 3.3e+129)
(* a (- (* b i) (* x t)))
(* b (* i (- a (* c (/ z i)))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)));
double tmp;
if (b <= -2.6e+110) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else if (b <= -3.4e+34) {
tmp = t_1;
} else if (b <= -5.3e-17) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else if (b <= -1.7e-70) {
tmp = y * ((x * z) - (i * j));
} else if (b <= 9.5e-21) {
tmp = t_1;
} else if (b <= 3.3e+129) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = b * (i * (a - (c * (z / i))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)))
if (b <= (-2.6d+110)) then
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)))
else if (b <= (-3.4d+34)) then
tmp = t_1
else if (b <= (-5.3d-17)) then
tmp = (t * ((c * j) - (x * a))) - (b * (z * c))
else if (b <= (-1.7d-70)) then
tmp = y * ((x * z) - (i * j))
else if (b <= 9.5d-21) then
tmp = t_1
else if (b <= 3.3d+129) then
tmp = a * ((b * i) - (x * t))
else
tmp = b * (i * (a - (c * (z / i))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)));
double tmp;
if (b <= -2.6e+110) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else if (b <= -3.4e+34) {
tmp = t_1;
} else if (b <= -5.3e-17) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else if (b <= -1.7e-70) {
tmp = y * ((x * z) - (i * j));
} else if (b <= 9.5e-21) {
tmp = t_1;
} else if (b <= 3.3e+129) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = b * (i * (a - (c * (z / i))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z))) tmp = 0 if b <= -2.6e+110: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) elif b <= -3.4e+34: tmp = t_1 elif b <= -5.3e-17: tmp = (t * ((c * j) - (x * a))) - (b * (z * c)) elif b <= -1.7e-70: tmp = y * ((x * z) - (i * j)) elif b <= 9.5e-21: tmp = t_1 elif b <= 3.3e+129: tmp = a * ((b * i) - (x * t)) else: tmp = b * (i * (a - (c * (z / i)))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) tmp = 0.0 if (b <= -2.6e+110) tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (b <= -3.4e+34) tmp = t_1; elseif (b <= -5.3e-17) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) - Float64(b * Float64(z * c))); elseif (b <= -1.7e-70) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (b <= 9.5e-21) tmp = t_1; elseif (b <= 3.3e+129) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = Float64(b * Float64(i * Float64(a - Float64(c * Float64(z / i))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z))); tmp = 0.0; if (b <= -2.6e+110) tmp = (t * (c * j)) + (b * ((a * i) - (z * c))); elseif (b <= -3.4e+34) tmp = t_1; elseif (b <= -5.3e-17) tmp = (t * ((c * j) - (x * a))) - (b * (z * c)); elseif (b <= -1.7e-70) tmp = y * ((x * z) - (i * j)); elseif (b <= 9.5e-21) tmp = t_1; elseif (b <= 3.3e+129) tmp = a * ((b * i) - (x * t)); else tmp = b * (i * (a - (c * (z / i)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.6e+110], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -3.4e+34], t$95$1, If[LessEqual[b, -5.3e-17], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.7e-70], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.5e-21], t$95$1, If[LessEqual[b, 3.3e+129], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(b * N[(i * N[(a - N[(c * N[(z / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right) - x \cdot \left(t \cdot a - y \cdot z\right)\\
\mathbf{if}\;b \leq -2.6 \cdot 10^{+110}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;b \leq -3.4 \cdot 10^{+34}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -5.3 \cdot 10^{-17}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) - b \cdot \left(z \cdot c\right)\\
\mathbf{elif}\;b \leq -1.7 \cdot 10^{-70}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;b \leq 9.5 \cdot 10^{-21}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 3.3 \cdot 10^{+129}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(i \cdot \left(a - c \cdot \frac{z}{i}\right)\right)\\
\end{array}
\end{array}
if b < -2.6e110Initial program 71.4%
Taylor expanded in y around 0 76.3%
+-commutative76.3%
*-commutative76.3%
associate-*r*74.1%
*-commutative74.1%
associate-*l*76.3%
mul-1-neg76.3%
associate-*r*73.9%
*-commutative73.9%
associate-*l*71.6%
distribute-rgt-neg-in71.6%
mul-1-neg71.6%
distribute-lft-in71.6%
mul-1-neg71.6%
unsub-neg71.6%
*-commutative71.6%
*-commutative71.6%
*-commutative71.6%
Simplified71.6%
Taylor expanded in j around inf 78.8%
associate-*r*78.8%
*-commutative78.8%
*-commutative78.8%
*-commutative78.8%
Simplified78.8%
if -2.6e110 < b < -3.3999999999999999e34 or -1.69999999999999998e-70 < b < 9.4999999999999994e-21Initial program 73.9%
Taylor expanded in b around 0 72.2%
if -3.3999999999999999e34 < b < -5.2999999999999998e-17Initial program 73.3%
Taylor expanded in y around 0 85.1%
+-commutative85.1%
*-commutative85.1%
associate-*r*85.1%
*-commutative85.1%
associate-*l*85.1%
mul-1-neg85.1%
associate-*r*67.8%
*-commutative67.8%
associate-*l*85.3%
distribute-rgt-neg-in85.3%
mul-1-neg85.3%
distribute-lft-in85.3%
mul-1-neg85.3%
unsub-neg85.3%
*-commutative85.3%
*-commutative85.3%
*-commutative85.3%
Simplified85.3%
Taylor expanded in z around inf 76.2%
if -5.2999999999999998e-17 < b < -1.69999999999999998e-70Initial program 65.0%
Taylor expanded in y around inf 63.7%
+-commutative63.7%
mul-1-neg63.7%
unsub-neg63.7%
Simplified63.7%
if 9.4999999999999994e-21 < b < 3.2999999999999999e129Initial program 81.1%
Taylor expanded in y around 0 77.5%
+-commutative77.5%
*-commutative77.5%
associate-*r*74.4%
*-commutative74.4%
associate-*l*77.3%
mul-1-neg77.3%
associate-*r*68.3%
*-commutative68.3%
associate-*l*74.6%
distribute-rgt-neg-in74.6%
mul-1-neg74.6%
distribute-lft-in77.8%
mul-1-neg77.8%
unsub-neg77.8%
*-commutative77.8%
*-commutative77.8%
*-commutative77.8%
Simplified77.8%
Taylor expanded in c around 0 68.1%
associate-*r*68.1%
neg-mul-168.1%
cancel-sign-sub68.1%
mul-1-neg68.1%
distribute-rgt-neg-in68.1%
mul-1-neg68.1%
distribute-lft-in71.3%
+-commutative71.3%
mul-1-neg71.3%
unsub-neg71.3%
Simplified71.3%
if 3.2999999999999999e129 < b Initial program 66.8%
Taylor expanded in b around inf 73.7%
*-commutative73.7%
Simplified73.7%
Taylor expanded in i around inf 75.7%
mul-1-neg75.7%
unsub-neg75.7%
associate-/l*75.8%
Simplified75.8%
Final simplification73.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (* x (- z (* i (/ j x)))))) (t_2 (* b (- (* a i) (* z c)))))
(if (<= y -4e+173)
t_1
(if (<= y -1e-34)
(- (* j (- (* t c) (* y i))) (* x (- (* t a) (* y z))))
(if (<= y -1.25e-92)
(+ (* y (- (* x z) (* i j))) t_2)
(if (<= y 3.6e+73) (+ (* t (- (* c j) (* x a))) 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 * (x * (z - (i * (j / x))));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (y <= -4e+173) {
tmp = t_1;
} else if (y <= -1e-34) {
tmp = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)));
} else if (y <= -1.25e-92) {
tmp = (y * ((x * z) - (i * j))) + t_2;
} else if (y <= 3.6e+73) {
tmp = (t * ((c * j) - (x * a))) + 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 * (x * (z - (i * (j / x))))
t_2 = b * ((a * i) - (z * c))
if (y <= (-4d+173)) then
tmp = t_1
else if (y <= (-1d-34)) then
tmp = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)))
else if (y <= (-1.25d-92)) then
tmp = (y * ((x * z) - (i * j))) + t_2
else if (y <= 3.6d+73) then
tmp = (t * ((c * j) - (x * a))) + 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 * (x * (z - (i * (j / x))));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (y <= -4e+173) {
tmp = t_1;
} else if (y <= -1e-34) {
tmp = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z)));
} else if (y <= -1.25e-92) {
tmp = (y * ((x * z) - (i * j))) + t_2;
} else if (y <= 3.6e+73) {
tmp = (t * ((c * j) - (x * a))) + t_2;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * (x * (z - (i * (j / x)))) t_2 = b * ((a * i) - (z * c)) tmp = 0 if y <= -4e+173: tmp = t_1 elif y <= -1e-34: tmp = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z))) elif y <= -1.25e-92: tmp = (y * ((x * z) - (i * j))) + t_2 elif y <= 3.6e+73: tmp = (t * ((c * j) - (x * a))) + t_2 else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))) t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (y <= -4e+173) tmp = t_1; elseif (y <= -1e-34) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))); elseif (y <= -1.25e-92) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + t_2); elseif (y <= 3.6e+73) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + 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 * (x * (z - (i * (j / x)))); t_2 = b * ((a * i) - (z * c)); tmp = 0.0; if (y <= -4e+173) tmp = t_1; elseif (y <= -1e-34) tmp = (j * ((t * c) - (y * i))) - (x * ((t * a) - (y * z))); elseif (y <= -1.25e-92) tmp = (y * ((x * z) - (i * j))) + t_2; elseif (y <= 3.6e+73) tmp = (t * ((c * j) - (x * a))) + 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[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4e+173], t$95$1, If[LessEqual[y, -1e-34], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.25e-92], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[y, 3.6e+73], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;y \leq -4 \cdot 10^{+173}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1 \cdot 10^{-34}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - x \cdot \left(t \cdot a - y \cdot z\right)\\
\mathbf{elif}\;y \leq -1.25 \cdot 10^{-92}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + t\_2\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{+73}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -4.0000000000000001e173 or 3.5999999999999999e73 < y Initial program 52.1%
Taylor expanded in y around inf 75.7%
+-commutative75.7%
mul-1-neg75.7%
unsub-neg75.7%
Simplified75.7%
Taylor expanded in x around inf 77.1%
mul-1-neg77.1%
unsub-neg77.1%
associate-/l*77.2%
Simplified77.2%
if -4.0000000000000001e173 < y < -9.99999999999999928e-35Initial program 65.4%
Taylor expanded in b around 0 76.1%
if -9.99999999999999928e-35 < y < -1.25000000000000003e-92Initial program 92.7%
Taylor expanded in t around 0 92.8%
associate-*r*86.1%
associate-*r*86.1%
*-commutative86.1%
associate-*r*79.0%
distribute-rgt-in79.0%
+-commutative79.0%
mul-1-neg79.0%
unsub-neg79.0%
*-commutative79.0%
Simplified79.0%
if -1.25000000000000003e-92 < y < 3.5999999999999999e73Initial program 83.7%
Taylor expanded in y around 0 82.6%
+-commutative82.6%
*-commutative82.6%
associate-*r*81.1%
*-commutative81.1%
associate-*l*81.7%
mul-1-neg81.7%
associate-*r*77.4%
*-commutative77.4%
associate-*l*81.1%
distribute-rgt-neg-in81.1%
mul-1-neg81.1%
distribute-lft-in82.6%
mul-1-neg82.6%
unsub-neg82.6%
*-commutative82.6%
*-commutative82.6%
*-commutative82.6%
Simplified82.6%
Final simplification79.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -1.08e-7)
(* y (- (* x z) (* i j)))
(if (<= y 1.45e-304)
(- (* t (- (* c j) (* x a))) (* b (* z c)))
(if (<= y 1.05e-278)
(- (* a (* b i)) (* a (* x t)))
(if (<= y 9.5e+73)
(+ (* t (* c j)) (* b (- (* a i) (* z c))))
(* y (* x (- z (* i (/ j x))))))))))
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.08e-7) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 1.45e-304) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else if (y <= 1.05e-278) {
tmp = (a * (b * i)) - (a * (x * t));
} else if (y <= 9.5e+73) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else {
tmp = y * (x * (z - (i * (j / x))));
}
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.08d-7)) then
tmp = y * ((x * z) - (i * j))
else if (y <= 1.45d-304) then
tmp = (t * ((c * j) - (x * a))) - (b * (z * c))
else if (y <= 1.05d-278) then
tmp = (a * (b * i)) - (a * (x * t))
else if (y <= 9.5d+73) then
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)))
else
tmp = y * (x * (z - (i * (j / x))))
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.08e-7) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 1.45e-304) {
tmp = (t * ((c * j) - (x * a))) - (b * (z * c));
} else if (y <= 1.05e-278) {
tmp = (a * (b * i)) - (a * (x * t));
} else if (y <= 9.5e+73) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -1.08e-7: tmp = y * ((x * z) - (i * j)) elif y <= 1.45e-304: tmp = (t * ((c * j) - (x * a))) - (b * (z * c)) elif y <= 1.05e-278: tmp = (a * (b * i)) - (a * (x * t)) elif y <= 9.5e+73: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) else: tmp = y * (x * (z - (i * (j / x)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -1.08e-7) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (y <= 1.45e-304) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) - Float64(b * Float64(z * c))); elseif (y <= 1.05e-278) tmp = Float64(Float64(a * Float64(b * i)) - Float64(a * Float64(x * t))); elseif (y <= 9.5e+73) tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -1.08e-7) tmp = y * ((x * z) - (i * j)); elseif (y <= 1.45e-304) tmp = (t * ((c * j) - (x * a))) - (b * (z * c)); elseif (y <= 1.05e-278) tmp = (a * (b * i)) - (a * (x * t)); elseif (y <= 9.5e+73) tmp = (t * (c * j)) + (b * ((a * i) - (z * c))); else tmp = y * (x * (z - (i * (j / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -1.08e-7], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.45e-304], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.05e-278], N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.5e+73], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.08 \cdot 10^{-7}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;y \leq 1.45 \cdot 10^{-304}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) - b \cdot \left(z \cdot c\right)\\
\mathbf{elif}\;y \leq 1.05 \cdot 10^{-278}:\\
\;\;\;\;a \cdot \left(b \cdot i\right) - a \cdot \left(x \cdot t\right)\\
\mathbf{elif}\;y \leq 9.5 \cdot 10^{+73}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
\end{array}
\end{array}
if y < -1.08000000000000001e-7Initial program 59.8%
Taylor expanded in y around inf 75.3%
+-commutative75.3%
mul-1-neg75.3%
unsub-neg75.3%
Simplified75.3%
if -1.08000000000000001e-7 < y < 1.45e-304Initial program 85.2%
Taylor expanded in y around 0 72.5%
+-commutative72.5%
*-commutative72.5%
associate-*r*68.7%
*-commutative68.7%
associate-*l*70.3%
mul-1-neg70.3%
associate-*r*70.4%
*-commutative70.4%
associate-*l*72.3%
distribute-rgt-neg-in72.3%
mul-1-neg72.3%
distribute-lft-in72.3%
mul-1-neg72.3%
unsub-neg72.3%
*-commutative72.3%
*-commutative72.3%
*-commutative72.3%
Simplified72.3%
Taylor expanded in z around inf 70.1%
if 1.45e-304 < y < 1.05000000000000007e-278Initial program 71.4%
Taylor expanded in t around -inf 57.7%
Simplified57.7%
Taylor expanded in a around -inf 85.9%
associate-*r*85.9%
*-commutative85.9%
+-commutative85.9%
mul-1-neg85.9%
unsub-neg85.9%
associate-/l*86.0%
Simplified86.0%
Taylor expanded in t around 0 86.1%
if 1.05000000000000007e-278 < y < 9.4999999999999996e73Initial program 85.0%
Taylor expanded in y around 0 82.2%
+-commutative82.2%
*-commutative82.2%
associate-*r*82.2%
*-commutative82.2%
associate-*l*83.1%
mul-1-neg83.1%
associate-*r*77.9%
*-commutative77.9%
associate-*l*82.2%
distribute-rgt-neg-in82.2%
mul-1-neg82.2%
distribute-lft-in84.3%
mul-1-neg84.3%
unsub-neg84.3%
*-commutative84.3%
*-commutative84.3%
*-commutative84.3%
Simplified84.3%
Taylor expanded in j around inf 68.7%
associate-*r*69.7%
*-commutative69.7%
*-commutative69.7%
*-commutative69.7%
Simplified69.7%
if 9.4999999999999996e73 < y Initial program 48.5%
Taylor expanded in y around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified71.1%
Taylor expanded in x around inf 71.1%
mul-1-neg71.1%
unsub-neg71.1%
associate-/l*71.4%
Simplified71.4%
Final simplification71.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* t (* c j)) (* b (- (* a i) (* z c))))))
(if (<= y -0.000135)
(* y (- (* x z) (* i j)))
(if (<= y 1.15e-22)
t_1
(if (<= y 1.85e-6)
(* a (- (* b i) (* x t)))
(if (<= y 8.4e+74) t_1 (* y (* x (- z (* i (/ j x)))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double tmp;
if (y <= -0.000135) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 1.15e-22) {
tmp = t_1;
} else if (y <= 1.85e-6) {
tmp = a * ((b * i) - (x * t));
} else if (y <= 8.4e+74) {
tmp = t_1;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (t * (c * j)) + (b * ((a * i) - (z * c)))
if (y <= (-0.000135d0)) then
tmp = y * ((x * z) - (i * j))
else if (y <= 1.15d-22) then
tmp = t_1
else if (y <= 1.85d-6) then
tmp = a * ((b * i) - (x * t))
else if (y <= 8.4d+74) then
tmp = t_1
else
tmp = y * (x * (z - (i * (j / x))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double tmp;
if (y <= -0.000135) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 1.15e-22) {
tmp = t_1;
} else if (y <= 1.85e-6) {
tmp = a * ((b * i) - (x * t));
} else if (y <= 8.4e+74) {
tmp = t_1;
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))) tmp = 0 if y <= -0.000135: tmp = y * ((x * z) - (i * j)) elif y <= 1.15e-22: tmp = t_1 elif y <= 1.85e-6: tmp = a * ((b * i) - (x * t)) elif y <= 8.4e+74: tmp = t_1 else: tmp = y * (x * (z - (i * (j / x)))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) tmp = 0.0 if (y <= -0.000135) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (y <= 1.15e-22) tmp = t_1; elseif (y <= 1.85e-6) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (y <= 8.4e+74) tmp = t_1; else tmp = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))); tmp = 0.0; if (y <= -0.000135) tmp = y * ((x * z) - (i * j)); elseif (y <= 1.15e-22) tmp = t_1; elseif (y <= 1.85e-6) tmp = a * ((b * i) - (x * t)); elseif (y <= 8.4e+74) tmp = t_1; else tmp = y * (x * (z - (i * (j / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -0.000135], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.15e-22], t$95$1, If[LessEqual[y, 1.85e-6], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.4e+74], t$95$1, N[(y * N[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;y \leq -0.000135:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;y \leq 1.15 \cdot 10^{-22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{-6}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;y \leq 8.4 \cdot 10^{+74}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
\end{array}
\end{array}
if y < -1.35000000000000002e-4Initial program 59.2%
Taylor expanded in y around inf 76.5%
+-commutative76.5%
mul-1-neg76.5%
unsub-neg76.5%
Simplified76.5%
if -1.35000000000000002e-4 < y < 1.1499999999999999e-22 or 1.8500000000000001e-6 < y < 8.3999999999999995e74Initial program 85.0%
Taylor expanded in y around 0 78.6%
+-commutative78.6%
*-commutative78.6%
associate-*r*77.2%
*-commutative77.2%
associate-*l*77.7%
mul-1-neg77.7%
associate-*r*75.0%
*-commutative75.0%
associate-*l*78.5%
distribute-rgt-neg-in78.5%
mul-1-neg78.5%
distribute-lft-in79.1%
mul-1-neg79.1%
unsub-neg79.1%
*-commutative79.1%
*-commutative79.1%
*-commutative79.1%
Simplified79.1%
Taylor expanded in j around inf 68.6%
associate-*r*67.7%
*-commutative67.7%
*-commutative67.7%
*-commutative67.7%
Simplified67.7%
if 1.1499999999999999e-22 < y < 1.8500000000000001e-6Initial program 75.8%
Taylor expanded in y around 0 75.8%
+-commutative75.8%
*-commutative75.8%
associate-*r*75.8%
*-commutative75.8%
associate-*l*75.8%
mul-1-neg75.8%
associate-*r*64.7%
*-commutative64.7%
associate-*l*64.7%
distribute-rgt-neg-in64.7%
mul-1-neg64.7%
distribute-lft-in77.2%
mul-1-neg77.2%
unsub-neg77.2%
*-commutative77.2%
*-commutative77.2%
*-commutative77.2%
Simplified77.2%
Taylor expanded in c around 0 100.0%
associate-*r*100.0%
neg-mul-1100.0%
cancel-sign-sub100.0%
mul-1-neg100.0%
distribute-rgt-neg-in100.0%
mul-1-neg100.0%
distribute-lft-in100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
Simplified100.0%
if 8.3999999999999995e74 < y Initial program 48.5%
Taylor expanded in y around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified71.1%
Taylor expanded in x around inf 71.1%
mul-1-neg71.1%
unsub-neg71.1%
associate-/l*71.4%
Simplified71.4%
Final simplification71.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -1.95e+179)
(* x (- (* y z) (* t a)))
(if (<= z -4.5e-115)
(* b (* i (- a (* c (/ z i)))))
(if (<= z 3.1e-281)
(* i (- (* a b) (* y j)))
(if (<= z 4e-240)
(* t (- (* c j) (* x a)))
(if (<= z 1.55e-77)
(* a (- (* b i) (* x t)))
(* z (- (* x y) (* b c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.95e+179) {
tmp = x * ((y * z) - (t * a));
} else if (z <= -4.5e-115) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 3.1e-281) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 4e-240) {
tmp = t * ((c * j) - (x * a));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-1.95d+179)) then
tmp = x * ((y * z) - (t * a))
else if (z <= (-4.5d-115)) then
tmp = b * (i * (a - (c * (z / i))))
else if (z <= 3.1d-281) then
tmp = i * ((a * b) - (y * j))
else if (z <= 4d-240) then
tmp = t * ((c * j) - (x * a))
else if (z <= 1.55d-77) then
tmp = a * ((b * i) - (x * t))
else
tmp = z * ((x * y) - (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.95e+179) {
tmp = x * ((y * z) - (t * a));
} else if (z <= -4.5e-115) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 3.1e-281) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 4e-240) {
tmp = t * ((c * j) - (x * a));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -1.95e+179: tmp = x * ((y * z) - (t * a)) elif z <= -4.5e-115: tmp = b * (i * (a - (c * (z / i)))) elif z <= 3.1e-281: tmp = i * ((a * b) - (y * j)) elif z <= 4e-240: tmp = t * ((c * j) - (x * a)) elif z <= 1.55e-77: tmp = a * ((b * i) - (x * t)) else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -1.95e+179) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (z <= -4.5e-115) tmp = Float64(b * Float64(i * Float64(a - Float64(c * Float64(z / i))))); elseif (z <= 3.1e-281) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (z <= 4e-240) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (z <= 1.55e-77) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -1.95e+179) tmp = x * ((y * z) - (t * a)); elseif (z <= -4.5e-115) tmp = b * (i * (a - (c * (z / i)))); elseif (z <= 3.1e-281) tmp = i * ((a * b) - (y * j)); elseif (z <= 4e-240) tmp = t * ((c * j) - (x * a)); elseif (z <= 1.55e-77) tmp = a * ((b * i) - (x * t)); else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -1.95e+179], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.5e-115], N[(b * N[(i * N[(a - N[(c * N[(z / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e-281], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e-240], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e-77], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.95 \cdot 10^{+179}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;z \leq -4.5 \cdot 10^{-115}:\\
\;\;\;\;b \cdot \left(i \cdot \left(a - c \cdot \frac{z}{i}\right)\right)\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-281}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;z \leq 4 \cdot 10^{-240}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-77}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if z < -1.94999999999999987e179Initial program 66.9%
+-commutative66.9%
fma-define66.9%
*-commutative66.9%
*-commutative66.9%
cancel-sign-sub-inv66.9%
cancel-sign-sub66.9%
sub-neg66.9%
sub-neg66.9%
*-commutative66.9%
fma-neg66.9%
*-commutative66.9%
distribute-rgt-neg-out66.9%
remove-double-neg66.9%
*-commutative66.9%
*-commutative66.9%
Simplified66.9%
Taylor expanded in x around inf 81.8%
if -1.94999999999999987e179 < z < -4.50000000000000023e-115Initial program 70.1%
Taylor expanded in b around inf 56.8%
*-commutative56.8%
Simplified56.8%
Taylor expanded in i around inf 61.1%
mul-1-neg61.1%
unsub-neg61.1%
associate-/l*61.1%
Simplified61.1%
if -4.50000000000000023e-115 < z < 3.1000000000000002e-281Initial program 79.7%
Taylor expanded in i around inf 67.7%
distribute-lft-out--67.7%
*-commutative67.7%
Simplified67.7%
if 3.1000000000000002e-281 < z < 3.9999999999999999e-240Initial program 80.0%
Taylor expanded in t around inf 99.7%
+-commutative99.7%
mul-1-neg99.7%
unsub-neg99.7%
*-commutative99.7%
*-commutative99.7%
Simplified99.7%
if 3.9999999999999999e-240 < z < 1.55000000000000004e-77Initial program 85.3%
Taylor expanded in y around 0 73.6%
+-commutative73.6%
*-commutative73.6%
associate-*r*73.6%
*-commutative73.6%
associate-*l*73.7%
mul-1-neg73.7%
associate-*r*70.6%
*-commutative70.6%
associate-*l*67.8%
distribute-rgt-neg-in67.8%
mul-1-neg67.8%
distribute-lft-in67.8%
mul-1-neg67.8%
unsub-neg67.8%
*-commutative67.8%
*-commutative67.8%
*-commutative67.8%
Simplified67.8%
Taylor expanded in c around 0 54.4%
associate-*r*54.4%
neg-mul-154.4%
cancel-sign-sub54.4%
mul-1-neg54.4%
distribute-rgt-neg-in54.4%
mul-1-neg54.4%
distribute-lft-in54.4%
+-commutative54.4%
mul-1-neg54.4%
unsub-neg54.4%
Simplified54.4%
if 1.55000000000000004e-77 < z Initial program 66.6%
Taylor expanded in z around inf 71.5%
*-commutative71.5%
Simplified71.5%
Final simplification67.5%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -1.45e+185)
(* y (- (* x z) (* i j)))
(if (<= z -3.8e-115)
(* b (* i (- a (* c (/ z i)))))
(if (<= z 3.1e-281)
(* i (- (* a b) (* y j)))
(if (<= z 1.25e-239)
(* t (- (* c j) (* x a)))
(if (<= z 1.55e-77)
(* a (- (* b i) (* x t)))
(* z (- (* x y) (* b c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.45e+185) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -3.8e-115) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 3.1e-281) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 1.25e-239) {
tmp = t * ((c * j) - (x * a));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-1.45d+185)) then
tmp = y * ((x * z) - (i * j))
else if (z <= (-3.8d-115)) then
tmp = b * (i * (a - (c * (z / i))))
else if (z <= 3.1d-281) then
tmp = i * ((a * b) - (y * j))
else if (z <= 1.25d-239) then
tmp = t * ((c * j) - (x * a))
else if (z <= 1.55d-77) then
tmp = a * ((b * i) - (x * t))
else
tmp = z * ((x * y) - (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.45e+185) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -3.8e-115) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 3.1e-281) {
tmp = i * ((a * b) - (y * j));
} else if (z <= 1.25e-239) {
tmp = t * ((c * j) - (x * a));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -1.45e+185: tmp = y * ((x * z) - (i * j)) elif z <= -3.8e-115: tmp = b * (i * (a - (c * (z / i)))) elif z <= 3.1e-281: tmp = i * ((a * b) - (y * j)) elif z <= 1.25e-239: tmp = t * ((c * j) - (x * a)) elif z <= 1.55e-77: tmp = a * ((b * i) - (x * t)) else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -1.45e+185) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (z <= -3.8e-115) tmp = Float64(b * Float64(i * Float64(a - Float64(c * Float64(z / i))))); elseif (z <= 3.1e-281) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (z <= 1.25e-239) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (z <= 1.55e-77) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -1.45e+185) tmp = y * ((x * z) - (i * j)); elseif (z <= -3.8e-115) tmp = b * (i * (a - (c * (z / i)))); elseif (z <= 3.1e-281) tmp = i * ((a * b) - (y * j)); elseif (z <= 1.25e-239) tmp = t * ((c * j) - (x * a)); elseif (z <= 1.55e-77) tmp = a * ((b * i) - (x * t)); else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -1.45e+185], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.8e-115], N[(b * N[(i * N[(a - N[(c * N[(z / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.1e-281], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.25e-239], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e-77], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.45 \cdot 10^{+185}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-115}:\\
\;\;\;\;b \cdot \left(i \cdot \left(a - c \cdot \frac{z}{i}\right)\right)\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-281}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{-239}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-77}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if z < -1.44999999999999994e185Initial program 66.9%
Taylor expanded in y around inf 74.7%
+-commutative74.7%
mul-1-neg74.7%
unsub-neg74.7%
Simplified74.7%
if -1.44999999999999994e185 < z < -3.79999999999999992e-115Initial program 70.1%
Taylor expanded in b around inf 56.8%
*-commutative56.8%
Simplified56.8%
Taylor expanded in i around inf 61.1%
mul-1-neg61.1%
unsub-neg61.1%
associate-/l*61.1%
Simplified61.1%
if -3.79999999999999992e-115 < z < 3.1000000000000002e-281Initial program 79.7%
Taylor expanded in i around inf 67.7%
distribute-lft-out--67.7%
*-commutative67.7%
Simplified67.7%
if 3.1000000000000002e-281 < z < 1.25e-239Initial program 80.0%
Taylor expanded in t around inf 99.7%
+-commutative99.7%
mul-1-neg99.7%
unsub-neg99.7%
*-commutative99.7%
*-commutative99.7%
Simplified99.7%
if 1.25e-239 < z < 1.55000000000000004e-77Initial program 85.3%
Taylor expanded in y around 0 73.6%
+-commutative73.6%
*-commutative73.6%
associate-*r*73.6%
*-commutative73.6%
associate-*l*73.7%
mul-1-neg73.7%
associate-*r*70.6%
*-commutative70.6%
associate-*l*67.8%
distribute-rgt-neg-in67.8%
mul-1-neg67.8%
distribute-lft-in67.8%
mul-1-neg67.8%
unsub-neg67.8%
*-commutative67.8%
*-commutative67.8%
*-commutative67.8%
Simplified67.8%
Taylor expanded in c around 0 54.4%
associate-*r*54.4%
neg-mul-154.4%
cancel-sign-sub54.4%
mul-1-neg54.4%
distribute-rgt-neg-in54.4%
mul-1-neg54.4%
distribute-lft-in54.4%
+-commutative54.4%
mul-1-neg54.4%
unsub-neg54.4%
Simplified54.4%
if 1.55000000000000004e-77 < z Initial program 66.6%
Taylor expanded in z around inf 71.5%
*-commutative71.5%
Simplified71.5%
Final simplification66.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t)))) (t_2 (* c (- (* t j) (* z b)))))
(if (<= c -1.15e+159)
t_2
(if (<= c -3e-23)
t_1
(if (<= c -2.05e-100)
(* j (- (* t c) (* y i)))
(if (<= c 700000.0) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.15e+159) {
tmp = t_2;
} else if (c <= -3e-23) {
tmp = t_1;
} else if (c <= -2.05e-100) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 700000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a * ((b * i) - (x * t))
t_2 = c * ((t * j) - (z * b))
if (c <= (-1.15d+159)) then
tmp = t_2
else if (c <= (-3d-23)) then
tmp = t_1
else if (c <= (-2.05d-100)) then
tmp = j * ((t * c) - (y * i))
else if (c <= 700000.0d0) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.15e+159) {
tmp = t_2;
} else if (c <= -3e-23) {
tmp = t_1;
} else if (c <= -2.05e-100) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 700000.0) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) t_2 = c * ((t * j) - (z * b)) tmp = 0 if c <= -1.15e+159: tmp = t_2 elif c <= -3e-23: tmp = t_1 elif c <= -2.05e-100: tmp = j * ((t * c) - (y * i)) elif c <= 700000.0: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) t_2 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -1.15e+159) tmp = t_2; elseif (c <= -3e-23) tmp = t_1; elseif (c <= -2.05e-100) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (c <= 700000.0) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); t_2 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -1.15e+159) tmp = t_2; elseif (c <= -3e-23) tmp = t_1; elseif (c <= -2.05e-100) tmp = j * ((t * c) - (y * i)); elseif (c <= 700000.0) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.15e+159], t$95$2, If[LessEqual[c, -3e-23], t$95$1, If[LessEqual[c, -2.05e-100], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 700000.0], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
t_2 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -1.15 \cdot 10^{+159}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;c \leq -3 \cdot 10^{-23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq -2.05 \cdot 10^{-100}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;c \leq 700000:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if c < -1.14999999999999998e159 or 7e5 < c Initial program 67.2%
Taylor expanded in c around inf 65.5%
*-commutative65.5%
*-commutative65.5%
Simplified65.5%
if -1.14999999999999998e159 < c < -3.00000000000000003e-23 or -2.0499999999999999e-100 < c < 7e5Initial program 75.9%
Taylor expanded in y around 0 62.5%
+-commutative62.5%
*-commutative62.5%
associate-*r*62.5%
*-commutative62.5%
associate-*l*62.5%
mul-1-neg62.5%
associate-*r*55.6%
*-commutative55.6%
associate-*l*57.1%
distribute-rgt-neg-in57.1%
mul-1-neg57.1%
distribute-lft-in57.9%
mul-1-neg57.9%
unsub-neg57.9%
*-commutative57.9%
*-commutative57.9%
*-commutative57.9%
Simplified57.9%
Taylor expanded in c around 0 53.8%
associate-*r*53.8%
neg-mul-153.8%
cancel-sign-sub53.8%
mul-1-neg53.8%
distribute-rgt-neg-in53.8%
mul-1-neg53.8%
distribute-lft-in56.3%
+-commutative56.3%
mul-1-neg56.3%
unsub-neg56.3%
Simplified56.3%
if -3.00000000000000003e-23 < c < -2.0499999999999999e-100Initial program 84.5%
Taylor expanded in j around inf 65.9%
Final simplification61.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= z -3e+192)
(* y (* x z))
(if (<= z -6e-28)
t_1
(if (<= z 1.7e-160)
(* a (- (* b i) (* x t)))
(if (<= z 2.4e+169) t_1 (* z (* x y))))))))
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 tmp;
if (z <= -3e+192) {
tmp = y * (x * z);
} else if (z <= -6e-28) {
tmp = t_1;
} else if (z <= 1.7e-160) {
tmp = a * ((b * i) - (x * t));
} else if (z <= 2.4e+169) {
tmp = t_1;
} else {
tmp = z * (x * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (z <= (-3d+192)) then
tmp = y * (x * z)
else if (z <= (-6d-28)) then
tmp = t_1
else if (z <= 1.7d-160) then
tmp = a * ((b * i) - (x * t))
else if (z <= 2.4d+169) then
tmp = t_1
else
tmp = z * (x * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (z <= -3e+192) {
tmp = y * (x * z);
} else if (z <= -6e-28) {
tmp = t_1;
} else if (z <= 1.7e-160) {
tmp = a * ((b * i) - (x * t));
} else if (z <= 2.4e+169) {
tmp = t_1;
} else {
tmp = z * (x * y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if z <= -3e+192: tmp = y * (x * z) elif z <= -6e-28: tmp = t_1 elif z <= 1.7e-160: tmp = a * ((b * i) - (x * t)) elif z <= 2.4e+169: tmp = t_1 else: tmp = z * (x * y) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (z <= -3e+192) tmp = Float64(y * Float64(x * z)); elseif (z <= -6e-28) tmp = t_1; elseif (z <= 1.7e-160) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (z <= 2.4e+169) tmp = t_1; else tmp = Float64(z * Float64(x * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (z <= -3e+192) tmp = y * (x * z); elseif (z <= -6e-28) tmp = t_1; elseif (z <= 1.7e-160) tmp = a * ((b * i) - (x * t)); elseif (z <= 2.4e+169) tmp = t_1; else tmp = z * (x * y); 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]}, If[LessEqual[z, -3e+192], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6e-28], t$95$1, If[LessEqual[z, 1.7e-160], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.4e+169], t$95$1, N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;z \leq -3 \cdot 10^{+192}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;z \leq -6 \cdot 10^{-28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.7 \cdot 10^{-160}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{+169}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\end{array}
\end{array}
if z < -3e192Initial program 64.2%
Taylor expanded in y around inf 80.5%
+-commutative80.5%
mul-1-neg80.5%
unsub-neg80.5%
Simplified80.5%
Taylor expanded in x around inf 65.4%
*-commutative65.4%
associate-*l*68.8%
Simplified68.8%
if -3e192 < z < -6.00000000000000005e-28 or 1.70000000000000011e-160 < z < 2.3999999999999998e169Initial program 71.2%
Taylor expanded in b around inf 51.8%
*-commutative51.8%
Simplified51.8%
if -6.00000000000000005e-28 < z < 1.70000000000000011e-160Initial program 80.0%
Taylor expanded in y around 0 67.6%
+-commutative67.6%
*-commutative67.6%
associate-*r*66.4%
*-commutative66.4%
associate-*l*67.1%
mul-1-neg67.1%
associate-*r*61.7%
*-commutative61.7%
associate-*l*63.8%
distribute-rgt-neg-in63.8%
mul-1-neg63.8%
distribute-lft-in65.0%
mul-1-neg65.0%
unsub-neg65.0%
*-commutative65.0%
*-commutative65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in c around 0 53.7%
associate-*r*53.7%
neg-mul-153.7%
cancel-sign-sub53.7%
mul-1-neg53.7%
distribute-rgt-neg-in53.7%
mul-1-neg53.7%
distribute-lft-in54.8%
+-commutative54.8%
mul-1-neg54.8%
unsub-neg54.8%
Simplified54.8%
if 2.3999999999999998e169 < z Initial program 63.1%
Taylor expanded in t around 0 70.0%
associate-*r*70.0%
associate-*r*70.0%
*-commutative70.0%
associate-*r*86.4%
distribute-rgt-in93.3%
+-commutative93.3%
mul-1-neg93.3%
unsub-neg93.3%
*-commutative93.3%
Simplified93.3%
Taylor expanded in x around inf 57.7%
associate-*r*70.7%
*-commutative70.7%
Simplified70.7%
Final simplification56.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* z c)))) (t_2 (* a (- (* b i) (* x t)))))
(if (<= a -1.2e-121)
t_2
(if (<= a -1.8e-230)
t_1
(if (<= a 6.2e-233) (* y (* x z)) (if (<= a 2.8e+29) 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 * -(z * c);
double t_2 = a * ((b * i) - (x * t));
double tmp;
if (a <= -1.2e-121) {
tmp = t_2;
} else if (a <= -1.8e-230) {
tmp = t_1;
} else if (a <= 6.2e-233) {
tmp = y * (x * z);
} else if (a <= 2.8e+29) {
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 * -(z * c)
t_2 = a * ((b * i) - (x * t))
if (a <= (-1.2d-121)) then
tmp = t_2
else if (a <= (-1.8d-230)) then
tmp = t_1
else if (a <= 6.2d-233) then
tmp = y * (x * z)
else if (a <= 2.8d+29) 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 * -(z * c);
double t_2 = a * ((b * i) - (x * t));
double tmp;
if (a <= -1.2e-121) {
tmp = t_2;
} else if (a <= -1.8e-230) {
tmp = t_1;
} else if (a <= 6.2e-233) {
tmp = y * (x * z);
} else if (a <= 2.8e+29) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * -(z * c) t_2 = a * ((b * i) - (x * t)) tmp = 0 if a <= -1.2e-121: tmp = t_2 elif a <= -1.8e-230: tmp = t_1 elif a <= 6.2e-233: tmp = y * (x * z) elif a <= 2.8e+29: 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(z * c))) t_2 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) tmp = 0.0 if (a <= -1.2e-121) tmp = t_2; elseif (a <= -1.8e-230) tmp = t_1; elseif (a <= 6.2e-233) tmp = Float64(y * Float64(x * z)); elseif (a <= 2.8e+29) 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 * -(z * c); t_2 = a * ((b * i) - (x * t)); tmp = 0.0; if (a <= -1.2e-121) tmp = t_2; elseif (a <= -1.8e-230) tmp = t_1; elseif (a <= 6.2e-233) tmp = y * (x * z); elseif (a <= 2.8e+29) 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[(z * c), $MachinePrecision])), $MachinePrecision]}, Block[{t$95$2 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.2e-121], t$95$2, If[LessEqual[a, -1.8e-230], t$95$1, If[LessEqual[a, 6.2e-233], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.8e+29], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(-z \cdot c\right)\\
t_2 := a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{if}\;a \leq -1.2 \cdot 10^{-121}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -1.8 \cdot 10^{-230}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{-233}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;a \leq 2.8 \cdot 10^{+29}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -1.20000000000000002e-121 or 2.8e29 < a Initial program 67.1%
Taylor expanded in y around 0 67.8%
+-commutative67.8%
*-commutative67.8%
associate-*r*67.0%
*-commutative67.0%
associate-*l*67.7%
mul-1-neg67.7%
associate-*r*60.5%
*-commutative60.5%
associate-*l*65.1%
distribute-rgt-neg-in65.1%
mul-1-neg65.1%
distribute-lft-in66.5%
mul-1-neg66.5%
unsub-neg66.5%
*-commutative66.5%
*-commutative66.5%
*-commutative66.5%
Simplified66.5%
Taylor expanded in c around 0 59.2%
associate-*r*59.2%
neg-mul-159.2%
cancel-sign-sub59.2%
mul-1-neg59.2%
distribute-rgt-neg-in59.2%
mul-1-neg59.2%
distribute-lft-in61.9%
+-commutative61.9%
mul-1-neg61.9%
unsub-neg61.9%
Simplified61.9%
if -1.20000000000000002e-121 < a < -1.7999999999999999e-230 or 6.2000000000000003e-233 < a < 2.8e29Initial program 80.0%
Taylor expanded in b around inf 47.2%
*-commutative47.2%
Simplified47.2%
Taylor expanded in a around 0 45.5%
mul-1-neg45.5%
*-commutative45.5%
distribute-rgt-neg-in45.5%
*-commutative45.5%
distribute-rgt-neg-in45.5%
Simplified45.5%
if -1.7999999999999999e-230 < a < 6.2000000000000003e-233Initial program 80.8%
Taylor expanded in y around inf 52.9%
+-commutative52.9%
mul-1-neg52.9%
unsub-neg52.9%
Simplified52.9%
Taylor expanded in x around inf 33.8%
*-commutative33.8%
associate-*l*36.5%
Simplified36.5%
Final simplification53.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -5.5e-5)
(* y (- (* x z) (* i j)))
(if (<= y 5.2e+75)
(+ (* t (- (* c j) (* x a))) (* b (- (* a i) (* z c))))
(* y (* x (- z (* i (/ j x))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -5.5e-5) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 5.2e+75) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else {
tmp = y * (x * (z - (i * (j / x))));
}
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 <= (-5.5d-5)) then
tmp = y * ((x * z) - (i * j))
else if (y <= 5.2d+75) then
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)))
else
tmp = y * (x * (z - (i * (j / x))))
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 <= -5.5e-5) {
tmp = y * ((x * z) - (i * j));
} else if (y <= 5.2e+75) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else {
tmp = y * (x * (z - (i * (j / x))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -5.5e-5: tmp = y * ((x * z) - (i * j)) elif y <= 5.2e+75: tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))) else: tmp = y * (x * (z - (i * (j / x)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -5.5e-5) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (y <= 5.2e+75) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(y * Float64(x * Float64(z - Float64(i * Float64(j / x))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -5.5e-5) tmp = y * ((x * z) - (i * j)); elseif (y <= 5.2e+75) tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))); else tmp = y * (x * (z - (i * (j / x)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -5.5e-5], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 5.2e+75], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(x * N[(z - N[(i * N[(j / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.5 \cdot 10^{-5}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;y \leq 5.2 \cdot 10^{+75}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot \left(z - i \cdot \frac{j}{x}\right)\right)\\
\end{array}
\end{array}
if y < -5.5000000000000002e-5Initial program 59.2%
Taylor expanded in y around inf 76.5%
+-commutative76.5%
mul-1-neg76.5%
unsub-neg76.5%
Simplified76.5%
if -5.5000000000000002e-5 < y < 5.1999999999999997e75Initial program 84.5%
Taylor expanded in y around 0 78.4%
+-commutative78.4%
*-commutative78.4%
associate-*r*77.1%
*-commutative77.1%
associate-*l*77.6%
mul-1-neg77.6%
associate-*r*74.5%
*-commutative74.5%
associate-*l*77.7%
distribute-rgt-neg-in77.7%
mul-1-neg77.7%
distribute-lft-in79.0%
mul-1-neg79.0%
unsub-neg79.0%
*-commutative79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
if 5.1999999999999997e75 < y Initial program 48.5%
Taylor expanded in y around inf 71.1%
+-commutative71.1%
mul-1-neg71.1%
unsub-neg71.1%
Simplified71.1%
Taylor expanded in x around inf 71.1%
mul-1-neg71.1%
unsub-neg71.1%
associate-/l*71.4%
Simplified71.4%
Final simplification77.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* a i))))
(if (<= i -8.6e+99)
t_1
(if (<= i 1.3e-206)
(* a (* t (- x)))
(if (<= i 1.95e-78)
(* y (* x z))
(if (<= i 8e+131) (* z (* b (- c))) 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 = b * (a * i);
double tmp;
if (i <= -8.6e+99) {
tmp = t_1;
} else if (i <= 1.3e-206) {
tmp = a * (t * -x);
} else if (i <= 1.95e-78) {
tmp = y * (x * z);
} else if (i <= 8e+131) {
tmp = z * (b * -c);
} 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 = b * (a * i)
if (i <= (-8.6d+99)) then
tmp = t_1
else if (i <= 1.3d-206) then
tmp = a * (t * -x)
else if (i <= 1.95d-78) then
tmp = y * (x * z)
else if (i <= 8d+131) then
tmp = z * (b * -c)
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 = b * (a * i);
double tmp;
if (i <= -8.6e+99) {
tmp = t_1;
} else if (i <= 1.3e-206) {
tmp = a * (t * -x);
} else if (i <= 1.95e-78) {
tmp = y * (x * z);
} else if (i <= 8e+131) {
tmp = z * (b * -c);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (a * i) tmp = 0 if i <= -8.6e+99: tmp = t_1 elif i <= 1.3e-206: tmp = a * (t * -x) elif i <= 1.95e-78: tmp = y * (x * z) elif i <= 8e+131: tmp = z * (b * -c) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(a * i)) tmp = 0.0 if (i <= -8.6e+99) tmp = t_1; elseif (i <= 1.3e-206) tmp = Float64(a * Float64(t * Float64(-x))); elseif (i <= 1.95e-78) tmp = Float64(y * Float64(x * z)); elseif (i <= 8e+131) tmp = Float64(z * Float64(b * Float64(-c))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (a * i); tmp = 0.0; if (i <= -8.6e+99) tmp = t_1; elseif (i <= 1.3e-206) tmp = a * (t * -x); elseif (i <= 1.95e-78) tmp = y * (x * z); elseif (i <= 8e+131) tmp = z * (b * -c); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -8.6e+99], t$95$1, If[LessEqual[i, 1.3e-206], N[(a * N[(t * (-x)), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.95e-78], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 8e+131], N[(z * N[(b * (-c)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i\right)\\
\mathbf{if}\;i \leq -8.6 \cdot 10^{+99}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 1.3 \cdot 10^{-206}:\\
\;\;\;\;a \cdot \left(t \cdot \left(-x\right)\right)\\
\mathbf{elif}\;i \leq 1.95 \cdot 10^{-78}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;i \leq 8 \cdot 10^{+131}:\\
\;\;\;\;z \cdot \left(b \cdot \left(-c\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -8.6000000000000003e99 or 7.9999999999999993e131 < i Initial program 66.4%
Taylor expanded in b around inf 59.4%
*-commutative59.4%
Simplified59.4%
Taylor expanded in a around inf 50.8%
if -8.6000000000000003e99 < i < 1.3e-206Initial program 81.2%
Taylor expanded in t around -inf 72.1%
Simplified72.1%
Taylor expanded in x around inf 44.1%
mul-1-neg44.1%
associate-*r*46.0%
distribute-rgt-neg-in46.0%
mul-1-neg46.0%
distribute-lft-out--46.0%
cancel-sign-sub-inv46.0%
metadata-eval46.0%
*-lft-identity46.0%
+-commutative46.0%
mul-1-neg46.0%
unsub-neg46.0%
associate-/l*45.9%
Simplified45.9%
Taylor expanded in y around 0 35.0%
neg-mul-135.0%
Simplified35.0%
if 1.3e-206 < i < 1.9500000000000001e-78Initial program 65.1%
Taylor expanded in y around inf 43.4%
+-commutative43.4%
mul-1-neg43.4%
unsub-neg43.4%
Simplified43.4%
Taylor expanded in x around inf 31.1%
*-commutative31.1%
associate-*l*43.2%
Simplified43.2%
if 1.9500000000000001e-78 < i < 7.9999999999999993e131Initial program 72.4%
Taylor expanded in z around inf 57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in x around 0 47.0%
neg-mul-147.0%
distribute-lft-neg-in47.0%
*-commutative47.0%
Simplified47.0%
Final simplification43.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* z c)))) (t_2 (* b (* a i))))
(if (<= a -1.8e-121)
t_2
(if (<= a -1.25e-228)
t_1
(if (<= a 1.5e-87) (* z (* x y)) (if (<= a 2.1e+30) 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 * -(z * c);
double t_2 = b * (a * i);
double tmp;
if (a <= -1.8e-121) {
tmp = t_2;
} else if (a <= -1.25e-228) {
tmp = t_1;
} else if (a <= 1.5e-87) {
tmp = z * (x * y);
} else if (a <= 2.1e+30) {
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 * -(z * c)
t_2 = b * (a * i)
if (a <= (-1.8d-121)) then
tmp = t_2
else if (a <= (-1.25d-228)) then
tmp = t_1
else if (a <= 1.5d-87) then
tmp = z * (x * y)
else if (a <= 2.1d+30) 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 * -(z * c);
double t_2 = b * (a * i);
double tmp;
if (a <= -1.8e-121) {
tmp = t_2;
} else if (a <= -1.25e-228) {
tmp = t_1;
} else if (a <= 1.5e-87) {
tmp = z * (x * y);
} else if (a <= 2.1e+30) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * -(z * c) t_2 = b * (a * i) tmp = 0 if a <= -1.8e-121: tmp = t_2 elif a <= -1.25e-228: tmp = t_1 elif a <= 1.5e-87: tmp = z * (x * y) elif a <= 2.1e+30: 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(z * c))) t_2 = Float64(b * Float64(a * i)) tmp = 0.0 if (a <= -1.8e-121) tmp = t_2; elseif (a <= -1.25e-228) tmp = t_1; elseif (a <= 1.5e-87) tmp = Float64(z * Float64(x * y)); elseif (a <= 2.1e+30) 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 * -(z * c); t_2 = b * (a * i); tmp = 0.0; if (a <= -1.8e-121) tmp = t_2; elseif (a <= -1.25e-228) tmp = t_1; elseif (a <= 1.5e-87) tmp = z * (x * y); elseif (a <= 2.1e+30) 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[(z * c), $MachinePrecision])), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.8e-121], t$95$2, If[LessEqual[a, -1.25e-228], t$95$1, If[LessEqual[a, 1.5e-87], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.1e+30], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(-z \cdot c\right)\\
t_2 := b \cdot \left(a \cdot i\right)\\
\mathbf{if}\;a \leq -1.8 \cdot 10^{-121}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -1.25 \cdot 10^{-228}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.5 \cdot 10^{-87}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;a \leq 2.1 \cdot 10^{+30}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if a < -1.79999999999999992e-121 or 2.1e30 < a Initial program 67.1%
Taylor expanded in b around inf 46.4%
*-commutative46.4%
Simplified46.4%
Taylor expanded in a around inf 40.8%
if -1.79999999999999992e-121 < a < -1.24999999999999993e-228 or 1.50000000000000008e-87 < a < 2.1e30Initial program 80.7%
Taylor expanded in b around inf 53.6%
*-commutative53.6%
Simplified53.6%
Taylor expanded in a around 0 51.3%
mul-1-neg51.3%
*-commutative51.3%
distribute-rgt-neg-in51.3%
*-commutative51.3%
distribute-rgt-neg-in51.3%
Simplified51.3%
if -1.24999999999999993e-228 < a < 1.50000000000000008e-87Initial program 79.8%
Taylor expanded in t around 0 68.3%
associate-*r*68.4%
associate-*r*68.4%
*-commutative68.4%
associate-*r*68.3%
distribute-rgt-in70.1%
+-commutative70.1%
mul-1-neg70.1%
unsub-neg70.1%
*-commutative70.1%
Simplified70.1%
Taylor expanded in x around inf 33.4%
associate-*r*35.0%
*-commutative35.0%
Simplified35.0%
Final simplification41.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -7.5e+187)
(* y (- (* x z) (* i j)))
(if (<= z -1.3e-28)
(* b (* i (- a (* c (/ z i)))))
(if (<= z 1.55e-77)
(* a (- (* b i) (* x t)))
(* z (- (* x y) (* b c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -7.5e+187) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -1.3e-28) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-7.5d+187)) then
tmp = y * ((x * z) - (i * j))
else if (z <= (-1.3d-28)) then
tmp = b * (i * (a - (c * (z / i))))
else if (z <= 1.55d-77) then
tmp = a * ((b * i) - (x * t))
else
tmp = z * ((x * y) - (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -7.5e+187) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -1.3e-28) {
tmp = b * (i * (a - (c * (z / i))));
} else if (z <= 1.55e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -7.5e+187: tmp = y * ((x * z) - (i * j)) elif z <= -1.3e-28: tmp = b * (i * (a - (c * (z / i)))) elif z <= 1.55e-77: tmp = a * ((b * i) - (x * t)) else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -7.5e+187) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (z <= -1.3e-28) tmp = Float64(b * Float64(i * Float64(a - Float64(c * Float64(z / i))))); elseif (z <= 1.55e-77) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -7.5e+187) tmp = y * ((x * z) - (i * j)); elseif (z <= -1.3e-28) tmp = b * (i * (a - (c * (z / i)))); elseif (z <= 1.55e-77) tmp = a * ((b * i) - (x * t)); else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -7.5e+187], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.3e-28], N[(b * N[(i * N[(a - N[(c * N[(z / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.55e-77], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -7.5 \cdot 10^{+187}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-28}:\\
\;\;\;\;b \cdot \left(i \cdot \left(a - c \cdot \frac{z}{i}\right)\right)\\
\mathbf{elif}\;z \leq 1.55 \cdot 10^{-77}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if z < -7.5000000000000002e187Initial program 65.6%
Taylor expanded in y around inf 77.6%
+-commutative77.6%
mul-1-neg77.6%
unsub-neg77.6%
Simplified77.6%
if -7.5000000000000002e187 < z < -1.3e-28Initial program 71.9%
Taylor expanded in b around inf 63.2%
*-commutative63.2%
Simplified63.2%
Taylor expanded in i around inf 67.2%
mul-1-neg67.2%
unsub-neg67.2%
associate-/l*67.2%
Simplified67.2%
if -1.3e-28 < z < 1.55000000000000004e-77Initial program 79.2%
Taylor expanded in y around 0 69.5%
+-commutative69.5%
*-commutative69.5%
associate-*r*68.5%
*-commutative68.5%
associate-*l*69.1%
mul-1-neg69.1%
associate-*r*63.6%
*-commutative63.6%
associate-*l*66.3%
distribute-rgt-neg-in66.3%
mul-1-neg66.3%
distribute-lft-in67.3%
mul-1-neg67.3%
unsub-neg67.3%
*-commutative67.3%
*-commutative67.3%
*-commutative67.3%
Simplified67.3%
Taylor expanded in c around 0 52.9%
associate-*r*52.9%
neg-mul-152.9%
cancel-sign-sub52.9%
mul-1-neg52.9%
distribute-rgt-neg-in52.9%
mul-1-neg52.9%
distribute-lft-in53.9%
+-commutative53.9%
mul-1-neg53.9%
unsub-neg53.9%
Simplified53.9%
if 1.55000000000000004e-77 < z Initial program 66.6%
Taylor expanded in z around inf 71.5%
*-commutative71.5%
Simplified71.5%
Final simplification64.1%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -2.4e+191)
(* y (- (* x z) (* i j)))
(if (<= z -5.4e-29)
(* b (- (* a i) (* z c)))
(if (<= z 1.25e-77)
(* a (- (* b i) (* x t)))
(* z (- (* x y) (* b c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.4e+191) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -5.4e-29) {
tmp = b * ((a * i) - (z * c));
} else if (z <= 1.25e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-2.4d+191)) then
tmp = y * ((x * z) - (i * j))
else if (z <= (-5.4d-29)) then
tmp = b * ((a * i) - (z * c))
else if (z <= 1.25d-77) then
tmp = a * ((b * i) - (x * t))
else
tmp = z * ((x * y) - (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -2.4e+191) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -5.4e-29) {
tmp = b * ((a * i) - (z * c));
} else if (z <= 1.25e-77) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -2.4e+191: tmp = y * ((x * z) - (i * j)) elif z <= -5.4e-29: tmp = b * ((a * i) - (z * c)) elif z <= 1.25e-77: tmp = a * ((b * i) - (x * t)) else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -2.4e+191) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (z <= -5.4e-29) tmp = Float64(b * Float64(Float64(a * i) - Float64(z * c))); elseif (z <= 1.25e-77) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -2.4e+191) tmp = y * ((x * z) - (i * j)); elseif (z <= -5.4e-29) tmp = b * ((a * i) - (z * c)); elseif (z <= 1.25e-77) tmp = a * ((b * i) - (x * t)); else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -2.4e+191], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.4e-29], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.25e-77], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.4 \cdot 10^{+191}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;z \leq -5.4 \cdot 10^{-29}:\\
\;\;\;\;b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;z \leq 1.25 \cdot 10^{-77}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if z < -2.39999999999999986e191Initial program 64.2%
Taylor expanded in y around inf 80.5%
+-commutative80.5%
mul-1-neg80.5%
unsub-neg80.5%
Simplified80.5%
if -2.39999999999999986e191 < z < -5.40000000000000045e-29Initial program 72.5%
Taylor expanded in b around inf 62.1%
*-commutative62.1%
Simplified62.1%
if -5.40000000000000045e-29 < z < 1.24999999999999991e-77Initial program 79.2%
Taylor expanded in y around 0 69.5%
+-commutative69.5%
*-commutative69.5%
associate-*r*68.5%
*-commutative68.5%
associate-*l*69.1%
mul-1-neg69.1%
associate-*r*63.6%
*-commutative63.6%
associate-*l*66.3%
distribute-rgt-neg-in66.3%
mul-1-neg66.3%
distribute-lft-in67.3%
mul-1-neg67.3%
unsub-neg67.3%
*-commutative67.3%
*-commutative67.3%
*-commutative67.3%
Simplified67.3%
Taylor expanded in c around 0 52.9%
associate-*r*52.9%
neg-mul-152.9%
cancel-sign-sub52.9%
mul-1-neg52.9%
distribute-rgt-neg-in52.9%
mul-1-neg52.9%
distribute-lft-in53.9%
+-commutative53.9%
mul-1-neg53.9%
unsub-neg53.9%
Simplified53.9%
if 1.24999999999999991e-77 < z Initial program 66.6%
Taylor expanded in z around inf 71.5%
*-commutative71.5%
Simplified71.5%
Final simplification63.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= a -2.7e+122)
(* x (* t (- a)))
(if (or (<= a -1.8e-121) (not (<= a 3.5e+31)))
(* b (* a i))
(* b (- (* 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 (a <= -2.7e+122) {
tmp = x * (t * -a);
} else if ((a <= -1.8e-121) || !(a <= 3.5e+31)) {
tmp = b * (a * i);
} else {
tmp = b * -(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 (a <= (-2.7d+122)) then
tmp = x * (t * -a)
else if ((a <= (-1.8d-121)) .or. (.not. (a <= 3.5d+31))) then
tmp = b * (a * i)
else
tmp = b * -(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 (a <= -2.7e+122) {
tmp = x * (t * -a);
} else if ((a <= -1.8e-121) || !(a <= 3.5e+31)) {
tmp = b * (a * i);
} else {
tmp = b * -(z * c);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= -2.7e+122: tmp = x * (t * -a) elif (a <= -1.8e-121) or not (a <= 3.5e+31): tmp = b * (a * i) else: tmp = b * -(z * c) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= -2.7e+122) tmp = Float64(x * Float64(t * Float64(-a))); elseif ((a <= -1.8e-121) || !(a <= 3.5e+31)) tmp = Float64(b * Float64(a * i)); else tmp = Float64(b * Float64(-Float64(z * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= -2.7e+122) tmp = x * (t * -a); elseif ((a <= -1.8e-121) || ~((a <= 3.5e+31))) tmp = b * (a * i); else tmp = b * -(z * c); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, -2.7e+122], N[(x * N[(t * (-a)), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[a, -1.8e-121], N[Not[LessEqual[a, 3.5e+31]], $MachinePrecision]], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(b * (-N[(z * c), $MachinePrecision])), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -2.7 \cdot 10^{+122}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-a\right)\right)\\
\mathbf{elif}\;a \leq -1.8 \cdot 10^{-121} \lor \neg \left(a \leq 3.5 \cdot 10^{+31}\right):\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(-z \cdot c\right)\\
\end{array}
\end{array}
if a < -2.6999999999999998e122Initial program 65.6%
+-commutative65.6%
fma-define70.0%
*-commutative70.0%
*-commutative70.0%
cancel-sign-sub-inv70.0%
cancel-sign-sub70.0%
sub-neg70.0%
sub-neg70.0%
*-commutative70.0%
fma-neg70.0%
*-commutative70.0%
distribute-rgt-neg-out70.0%
remove-double-neg70.0%
*-commutative70.0%
*-commutative70.0%
Simplified70.0%
Taylor expanded in x around inf 55.4%
Taylor expanded in a around inf 46.7%
mul-1-neg46.7%
associate-*r*49.0%
distribute-lft-neg-out49.0%
*-commutative49.0%
*-commutative49.0%
distribute-rgt-neg-in49.0%
Simplified49.0%
if -2.6999999999999998e122 < a < -1.79999999999999992e-121 or 3.5e31 < a Initial program 67.7%
Taylor expanded in b around inf 47.3%
*-commutative47.3%
Simplified47.3%
Taylor expanded in a around inf 41.1%
if -1.79999999999999992e-121 < a < 3.5e31Initial program 80.2%
Taylor expanded in b around inf 41.6%
*-commutative41.6%
Simplified41.6%
Taylor expanded in a around 0 38.7%
mul-1-neg38.7%
*-commutative38.7%
distribute-rgt-neg-in38.7%
*-commutative38.7%
distribute-rgt-neg-in38.7%
Simplified38.7%
Final simplification41.5%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= c -8.2e+158) (not (<= c 3500000.0))) (* c (- (* t j) (* z b))) (* a (- (* b i) (* x t)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -8.2e+158) || !(c <= 3500000.0)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((c <= (-8.2d+158)) .or. (.not. (c <= 3500000.0d0))) then
tmp = c * ((t * j) - (z * b))
else
tmp = a * ((b * i) - (x * t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -8.2e+158) || !(c <= 3500000.0)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (c <= -8.2e+158) or not (c <= 3500000.0): tmp = c * ((t * j) - (z * b)) else: tmp = a * ((b * i) - (x * t)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((c <= -8.2e+158) || !(c <= 3500000.0)) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((c <= -8.2e+158) || ~((c <= 3500000.0))) tmp = c * ((t * j) - (z * b)); else tmp = a * ((b * i) - (x * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[c, -8.2e+158], N[Not[LessEqual[c, 3500000.0]], $MachinePrecision]], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -8.2 \cdot 10^{+158} \lor \neg \left(c \leq 3500000\right):\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\end{array}
\end{array}
if c < -8.20000000000000008e158 or 3.5e6 < c Initial program 67.2%
Taylor expanded in c around inf 65.5%
*-commutative65.5%
*-commutative65.5%
Simplified65.5%
if -8.20000000000000008e158 < c < 3.5e6Initial program 77.1%
Taylor expanded in y around 0 60.9%
+-commutative60.9%
*-commutative60.9%
associate-*r*61.5%
*-commutative61.5%
associate-*l*61.5%
mul-1-neg61.5%
associate-*r*54.9%
*-commutative54.9%
associate-*l*56.8%
distribute-rgt-neg-in56.8%
mul-1-neg56.8%
distribute-lft-in57.5%
mul-1-neg57.5%
unsub-neg57.5%
*-commutative57.5%
*-commutative57.5%
*-commutative57.5%
Simplified57.5%
Taylor expanded in c around 0 50.8%
associate-*r*50.8%
neg-mul-150.8%
cancel-sign-sub50.8%
mul-1-neg50.8%
distribute-rgt-neg-in50.8%
mul-1-neg50.8%
distribute-lft-in52.9%
+-commutative52.9%
mul-1-neg52.9%
unsub-neg52.9%
Simplified52.9%
Final simplification58.5%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= z -9.5e+125) (not (<= z 1.55e-11))) (* y (* x z)) (* b (* a i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -9.5e+125) || !(z <= 1.55e-11)) {
tmp = y * (x * z);
} else {
tmp = b * (a * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((z <= (-9.5d+125)) .or. (.not. (z <= 1.55d-11))) then
tmp = y * (x * z)
else
tmp = b * (a * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -9.5e+125) || !(z <= 1.55e-11)) {
tmp = y * (x * z);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (z <= -9.5e+125) or not (z <= 1.55e-11): tmp = y * (x * z) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((z <= -9.5e+125) || !(z <= 1.55e-11)) tmp = Float64(y * Float64(x * z)); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((z <= -9.5e+125) || ~((z <= 1.55e-11))) tmp = y * (x * z); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[z, -9.5e+125], N[Not[LessEqual[z, 1.55e-11]], $MachinePrecision]], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.5 \cdot 10^{+125} \lor \neg \left(z \leq 1.55 \cdot 10^{-11}\right):\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if z < -9.50000000000000041e125 or 1.55000000000000014e-11 < z Initial program 65.3%
Taylor expanded in y around inf 58.4%
+-commutative58.4%
mul-1-neg58.4%
unsub-neg58.4%
Simplified58.4%
Taylor expanded in x around inf 43.8%
*-commutative43.8%
associate-*l*47.5%
Simplified47.5%
if -9.50000000000000041e125 < z < 1.55000000000000014e-11Initial program 77.1%
Taylor expanded in b around inf 45.0%
*-commutative45.0%
Simplified45.0%
Taylor expanded in a around inf 31.5%
Final simplification37.5%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= z -1.4e+197) (not (<= z 4.4e-13))) (* x (* y z)) (* b (* a i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -1.4e+197) || !(z <= 4.4e-13)) {
tmp = x * (y * z);
} else {
tmp = b * (a * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((z <= (-1.4d+197)) .or. (.not. (z <= 4.4d-13))) then
tmp = x * (y * z)
else
tmp = b * (a * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((z <= -1.4e+197) || !(z <= 4.4e-13)) {
tmp = x * (y * z);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (z <= -1.4e+197) or not (z <= 4.4e-13): tmp = x * (y * z) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((z <= -1.4e+197) || !(z <= 4.4e-13)) tmp = Float64(x * Float64(y * z)); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((z <= -1.4e+197) || ~((z <= 4.4e-13))) tmp = x * (y * z); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[z, -1.4e+197], N[Not[LessEqual[z, 4.4e-13]], $MachinePrecision]], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.4 \cdot 10^{+197} \lor \neg \left(z \leq 4.4 \cdot 10^{-13}\right):\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if z < -1.3999999999999999e197 or 4.39999999999999993e-13 < z Initial program 65.0%
+-commutative65.0%
fma-define67.4%
*-commutative67.4%
*-commutative67.4%
cancel-sign-sub-inv67.4%
cancel-sign-sub67.4%
sub-neg67.4%
sub-neg67.4%
*-commutative67.4%
fma-neg67.4%
*-commutative67.4%
distribute-rgt-neg-out67.4%
remove-double-neg67.4%
*-commutative67.4%
*-commutative67.4%
Simplified67.4%
Taylor expanded in x around inf 54.4%
Taylor expanded in a around 0 48.3%
*-commutative48.3%
Simplified48.3%
if -1.3999999999999999e197 < z < 4.39999999999999993e-13Initial program 76.4%
Taylor expanded in b around inf 44.8%
*-commutative44.8%
Simplified44.8%
Taylor expanded in a around inf 30.6%
Final simplification36.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= c -4.2e+106) (not (<= c 920000.0))) (* 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 ((c <= -4.2e+106) || !(c <= 920000.0)) {
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 ((c <= (-4.2d+106)) .or. (.not. (c <= 920000.0d0))) 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 ((c <= -4.2e+106) || !(c <= 920000.0)) {
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 (c <= -4.2e+106) or not (c <= 920000.0): 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 ((c <= -4.2e+106) || !(c <= 920000.0)) 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 ((c <= -4.2e+106) || ~((c <= 920000.0))) 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[c, -4.2e+106], N[Not[LessEqual[c, 920000.0]], $MachinePrecision]], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -4.2 \cdot 10^{+106} \lor \neg \left(c \leq 920000\right):\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if c < -4.2000000000000001e106 or 9.2e5 < c Initial program 67.2%
Taylor expanded in t around inf 43.0%
+-commutative43.0%
mul-1-neg43.0%
unsub-neg43.0%
*-commutative43.0%
*-commutative43.0%
Simplified43.0%
Taylor expanded in j around inf 35.3%
*-commutative35.3%
Simplified35.3%
if -4.2000000000000001e106 < c < 9.2e5Initial program 77.6%
Taylor expanded in b around inf 40.5%
*-commutative40.5%
Simplified40.5%
Taylor expanded in a around inf 33.0%
Final simplification34.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= z -9e+125) (* y (* x z)) (if (<= z 2.05e-11) (* b (* a i)) (* z (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -9e+125) {
tmp = y * (x * z);
} else if (z <= 2.05e-11) {
tmp = b * (a * i);
} else {
tmp = z * (x * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-9d+125)) then
tmp = y * (x * z)
else if (z <= 2.05d-11) then
tmp = b * (a * i)
else
tmp = z * (x * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -9e+125) {
tmp = y * (x * z);
} else if (z <= 2.05e-11) {
tmp = b * (a * i);
} else {
tmp = z * (x * y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -9e+125: tmp = y * (x * z) elif z <= 2.05e-11: tmp = b * (a * i) else: tmp = z * (x * y) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -9e+125) tmp = Float64(y * Float64(x * z)); elseif (z <= 2.05e-11) tmp = Float64(b * Float64(a * i)); else tmp = Float64(z * Float64(x * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -9e+125) tmp = y * (x * z); elseif (z <= 2.05e-11) tmp = b * (a * i); else tmp = z * (x * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -9e+125], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.05e-11], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9 \cdot 10^{+125}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;z \leq 2.05 \cdot 10^{-11}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\end{array}
\end{array}
if z < -9.0000000000000001e125Initial program 66.8%
Taylor expanded in y around inf 64.6%
+-commutative64.6%
mul-1-neg64.6%
unsub-neg64.6%
Simplified64.6%
Taylor expanded in x around inf 53.2%
*-commutative53.2%
associate-*l*55.7%
Simplified55.7%
if -9.0000000000000001e125 < z < 2.05e-11Initial program 77.1%
Taylor expanded in b around inf 45.0%
*-commutative45.0%
Simplified45.0%
Taylor expanded in a around inf 31.5%
if 2.05e-11 < z Initial program 64.5%
Taylor expanded in t around 0 64.2%
associate-*r*64.2%
associate-*r*64.2%
*-commutative64.2%
associate-*r*68.7%
distribute-rgt-in73.5%
+-commutative73.5%
mul-1-neg73.5%
unsub-neg73.5%
*-commutative73.5%
Simplified73.5%
Taylor expanded in x around inf 38.9%
associate-*r*44.9%
*-commutative44.9%
Simplified44.9%
Final simplification37.9%
(FPCore (x y z t a b c i j) :precision binary64 (* b (* a i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = b * (a * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
def code(x, y, z, t, a, b, c, i, j): return b * (a * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(b * Float64(a * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = b * (a * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
b \cdot \left(a \cdot i\right)
\end{array}
Initial program 72.7%
Taylor expanded in b around inf 44.4%
*-commutative44.4%
Simplified44.4%
Taylor expanded in a around inf 26.2%
(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 72.7%
Taylor expanded in b around inf 44.4%
*-commutative44.4%
Simplified44.4%
Taylor expanded in a around inf 24.3%
(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 2024103
(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)))))