
(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 21 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
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* 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 t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = a * ((b * i) - (x * t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = a * ((b * i) - (x * t)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(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) t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = a * ((b * i) - (x * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 91.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 3.8%
mul-1-neg3.8%
unsub-neg3.8%
associate-/l*7.5%
Simplified7.5%
Taylor expanded in a around -inf 51.9%
Final simplification83.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* j (- (* t c) (* y i))) (* a (* b i))))
(t_2 (* i (- (* a b) (* y j)))))
(if (<= i -1.4e+144)
t_2
(if (<= i -5.2e-83)
t_1
(if (<= i 8.5e-184)
(* x (- (* y z) (* t a)))
(if (<= i 1.2e-58)
(* t (- (* c j) (* x a)))
(if (<= i 2.6e+138) t_1 t_2)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((t * c) - (y * i))) + (a * (b * i));
double t_2 = i * ((a * b) - (y * j));
double tmp;
if (i <= -1.4e+144) {
tmp = t_2;
} else if (i <= -5.2e-83) {
tmp = t_1;
} else if (i <= 8.5e-184) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 1.2e-58) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 2.6e+138) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (j * ((t * c) - (y * i))) + (a * (b * i))
t_2 = i * ((a * b) - (y * j))
if (i <= (-1.4d+144)) then
tmp = t_2
else if (i <= (-5.2d-83)) then
tmp = t_1
else if (i <= 8.5d-184) then
tmp = x * ((y * z) - (t * a))
else if (i <= 1.2d-58) then
tmp = t * ((c * j) - (x * a))
else if (i <= 2.6d+138) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((t * c) - (y * i))) + (a * (b * i));
double t_2 = i * ((a * b) - (y * j));
double tmp;
if (i <= -1.4e+144) {
tmp = t_2;
} else if (i <= -5.2e-83) {
tmp = t_1;
} else if (i <= 8.5e-184) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 1.2e-58) {
tmp = t * ((c * j) - (x * a));
} else if (i <= 2.6e+138) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (j * ((t * c) - (y * i))) + (a * (b * i)) t_2 = i * ((a * b) - (y * j)) tmp = 0 if i <= -1.4e+144: tmp = t_2 elif i <= -5.2e-83: tmp = t_1 elif i <= 8.5e-184: tmp = x * ((y * z) - (t * a)) elif i <= 1.2e-58: tmp = t * ((c * j) - (x * a)) elif i <= 2.6e+138: tmp = t_1 else: tmp = t_2 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(a * Float64(b * i))) t_2 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (i <= -1.4e+144) tmp = t_2; elseif (i <= -5.2e-83) tmp = t_1; elseif (i <= 8.5e-184) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (i <= 1.2e-58) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (i <= 2.6e+138) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (j * ((t * c) - (y * i))) + (a * (b * i)); t_2 = i * ((a * b) - (y * j)); tmp = 0.0; if (i <= -1.4e+144) tmp = t_2; elseif (i <= -5.2e-83) tmp = t_1; elseif (i <= 8.5e-184) tmp = x * ((y * z) - (t * a)); elseif (i <= 1.2e-58) tmp = t * ((c * j) - (x * a)); elseif (i <= 2.6e+138) 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[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.4e+144], t$95$2, If[LessEqual[i, -5.2e-83], t$95$1, If[LessEqual[i, 8.5e-184], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.2e-58], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.6e+138], t$95$1, t$95$2]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right) + a \cdot \left(b \cdot i\right)\\
t_2 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -1.4 \cdot 10^{+144}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;i \leq -5.2 \cdot 10^{-83}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 8.5 \cdot 10^{-184}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;i \leq 1.2 \cdot 10^{-58}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;i \leq 2.6 \cdot 10^{+138}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if i < -1.40000000000000003e144 or 2.6000000000000001e138 < i Initial program 52.5%
+-commutative52.5%
fma-define53.8%
*-commutative53.8%
*-commutative53.8%
cancel-sign-sub-inv53.8%
cancel-sign-sub53.8%
fma-neg55.2%
distribute-rgt-neg-out55.2%
remove-double-neg55.2%
*-commutative55.2%
*-commutative55.2%
Simplified55.2%
Taylor expanded in i around inf 77.8%
distribute-lft-out--77.8%
*-commutative77.8%
Simplified77.8%
Taylor expanded in i around 0 77.8%
mul-1-neg77.8%
*-commutative77.8%
distribute-rgt-neg-out77.8%
neg-mul-177.8%
*-commutative77.8%
distribute-lft-out--77.8%
sub-neg77.8%
neg-mul-177.8%
remove-double-neg77.8%
+-commutative77.8%
mul-1-neg77.8%
*-commutative77.8%
unsub-neg77.8%
Simplified77.8%
if -1.40000000000000003e144 < i < -5.20000000000000018e-83 or 1.2e-58 < i < 2.6000000000000001e138Initial program 84.0%
cancel-sign-sub-inv84.0%
cancel-sign-sub84.0%
*-commutative84.0%
fma-neg85.2%
distribute-rgt-neg-in85.2%
remove-double-neg85.2%
*-commutative85.2%
*-commutative85.2%
sub-neg85.2%
sub-neg85.2%
*-commutative85.2%
*-commutative85.2%
Simplified85.2%
Taylor expanded in i around inf 68.7%
if -5.20000000000000018e-83 < i < 8.50000000000000036e-184Initial program 80.3%
Taylor expanded in j around 0 73.0%
Taylor expanded in x around inf 65.6%
*-commutative65.6%
Simplified65.6%
if 8.50000000000000036e-184 < i < 1.2e-58Initial program 74.0%
+-commutative74.0%
fma-define82.7%
*-commutative82.7%
*-commutative82.7%
cancel-sign-sub-inv82.7%
cancel-sign-sub82.7%
fma-neg82.7%
distribute-rgt-neg-out82.7%
remove-double-neg82.7%
*-commutative82.7%
*-commutative82.7%
Simplified82.7%
Taylor expanded in t around inf 70.3%
+-commutative70.3%
mul-1-neg70.3%
unsub-neg70.3%
*-commutative70.3%
Simplified70.3%
Final simplification70.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* j (- (* t c) (* y i))) (* z (- (* x y) (* b c))))))
(if (<= y -1.5e+220)
(* y (- (* x z) (* i j)))
(if (<= y -8.2e+63)
t_1
(if (<= y 6.3e+44)
(+ (* t (- (* c j) (* x a))) (* b (- (* a i) (* z c))))
(if (<= y 1.05e+217) t_1 (* i (- (* a b) (* y j)))))))))
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))) + (z * ((x * y) - (b * c)));
double tmp;
if (y <= -1.5e+220) {
tmp = y * ((x * z) - (i * j));
} else if (y <= -8.2e+63) {
tmp = t_1;
} else if (y <= 6.3e+44) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else if (y <= 1.05e+217) {
tmp = t_1;
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)))
if (y <= (-1.5d+220)) then
tmp = y * ((x * z) - (i * j))
else if (y <= (-8.2d+63)) then
tmp = t_1
else if (y <= 6.3d+44) then
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)))
else if (y <= 1.05d+217) then
tmp = t_1
else
tmp = i * ((a * b) - (y * j))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)));
double tmp;
if (y <= -1.5e+220) {
tmp = y * ((x * z) - (i * j));
} else if (y <= -8.2e+63) {
tmp = t_1;
} else if (y <= 6.3e+44) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else if (y <= 1.05e+217) {
tmp = t_1;
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c))) tmp = 0 if y <= -1.5e+220: tmp = y * ((x * z) - (i * j)) elif y <= -8.2e+63: tmp = t_1 elif y <= 6.3e+44: tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))) elif y <= 1.05e+217: tmp = t_1 else: tmp = i * ((a * b) - (y * j)) 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(z * Float64(Float64(x * y) - Float64(b * c)))) tmp = 0.0 if (y <= -1.5e+220) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (y <= -8.2e+63) tmp = t_1; elseif (y <= 6.3e+44) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (y <= 1.05e+217) tmp = t_1; else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c))); tmp = 0.0; if (y <= -1.5e+220) tmp = y * ((x * z) - (i * j)); elseif (y <= -8.2e+63) tmp = t_1; elseif (y <= 6.3e+44) tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))); elseif (y <= 1.05e+217) tmp = t_1; else tmp = i * ((a * b) - (y * j)); 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[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.5e+220], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -8.2e+63], t$95$1, If[LessEqual[y, 6.3e+44], 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], If[LessEqual[y, 1.05e+217], t$95$1, N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right) + z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;y \leq -1.5 \cdot 10^{+220}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;y \leq -8.2 \cdot 10^{+63}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 6.3 \cdot 10^{+44}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;y \leq 1.05 \cdot 10^{+217}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if y < -1.50000000000000012e220Initial program 37.3%
+-commutative37.3%
fma-define37.3%
*-commutative37.3%
*-commutative37.3%
cancel-sign-sub-inv37.3%
cancel-sign-sub37.3%
fma-neg44.5%
distribute-rgt-neg-out44.5%
remove-double-neg44.5%
*-commutative44.5%
*-commutative44.5%
Simplified44.5%
Taylor expanded in y around inf 65.9%
+-commutative65.9%
mul-1-neg65.9%
unsub-neg65.9%
Simplified65.9%
if -1.50000000000000012e220 < y < -8.19999999999999985e63 or 6.3e44 < y < 1.05e217Initial program 66.4%
cancel-sign-sub-inv66.4%
cancel-sign-sub66.4%
*-commutative66.4%
fma-neg66.4%
distribute-rgt-neg-in66.4%
remove-double-neg66.4%
*-commutative66.4%
*-commutative66.4%
sub-neg66.4%
sub-neg66.4%
*-commutative66.4%
*-commutative66.4%
Simplified66.4%
Taylor expanded in z around inf 73.2%
if -8.19999999999999985e63 < y < 6.3e44Initial program 80.7%
+-commutative80.7%
fma-define82.1%
*-commutative82.1%
*-commutative82.1%
cancel-sign-sub-inv82.1%
cancel-sign-sub82.1%
fma-neg82.8%
distribute-rgt-neg-out82.8%
remove-double-neg82.8%
*-commutative82.8%
*-commutative82.8%
Simplified82.8%
Taylor expanded in y around 0 72.4%
*-commutative72.4%
*-commutative72.4%
associate-*r*74.4%
*-commutative74.4%
associate-*r*74.4%
*-commutative74.4%
*-commutative74.4%
associate-*r*74.4%
*-commutative74.4%
associate-*r*76.4%
distribute-lft-in77.1%
+-commutative77.1%
mul-1-neg77.1%
unsub-neg77.1%
*-commutative77.1%
*-commutative77.1%
Simplified77.1%
if 1.05e217 < y Initial program 67.1%
+-commutative67.1%
fma-define67.1%
*-commutative67.1%
*-commutative67.1%
cancel-sign-sub-inv67.1%
cancel-sign-sub67.1%
fma-neg67.1%
distribute-rgt-neg-out67.1%
remove-double-neg67.1%
*-commutative67.1%
*-commutative67.1%
Simplified67.1%
Taylor expanded in i around inf 78.4%
distribute-lft-out--78.4%
*-commutative78.4%
Simplified78.4%
Taylor expanded in i around 0 78.4%
mul-1-neg78.4%
*-commutative78.4%
distribute-rgt-neg-out78.4%
neg-mul-178.4%
*-commutative78.4%
distribute-lft-out--78.4%
sub-neg78.4%
neg-mul-178.4%
remove-double-neg78.4%
+-commutative78.4%
mul-1-neg78.4%
*-commutative78.4%
unsub-neg78.4%
Simplified78.4%
Final simplification75.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* t (* c j)) (* b (- (* a i) (* z c)))))
(t_2 (* j (- (* t c) (* y i)))))
(if (<= b -3.2e+62)
t_1
(if (<= b -2.1e-55)
(+ t_2 (* a (* b i)))
(if (<= b -4.7e-241)
(* z (+ (* x y) (* t (/ (- (* c j) (* x a)) z))))
(if (<= b 2.1e+143) (+ t_2 (* z (- (* x y) (* 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 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (b <= -3.2e+62) {
tmp = t_1;
} else if (b <= -2.1e-55) {
tmp = t_2 + (a * (b * i));
} else if (b <= -4.7e-241) {
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)));
} else if (b <= 2.1e+143) {
tmp = t_2 + (z * ((x * y) - (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) :: t_2
real(8) :: tmp
t_1 = (t * (c * j)) + (b * ((a * i) - (z * c)))
t_2 = j * ((t * c) - (y * i))
if (b <= (-3.2d+62)) then
tmp = t_1
else if (b <= (-2.1d-55)) then
tmp = t_2 + (a * (b * i))
else if (b <= (-4.7d-241)) then
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)))
else if (b <= 2.1d+143) then
tmp = t_2 + (z * ((x * y) - (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 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (b <= -3.2e+62) {
tmp = t_1;
} else if (b <= -2.1e-55) {
tmp = t_2 + (a * (b * i));
} else if (b <= -4.7e-241) {
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)));
} else if (b <= 2.1e+143) {
tmp = t_2 + (z * ((x * y) - (b * c)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))) t_2 = j * ((t * c) - (y * i)) tmp = 0 if b <= -3.2e+62: tmp = t_1 elif b <= -2.1e-55: tmp = t_2 + (a * (b * i)) elif b <= -4.7e-241: tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z))) elif b <= 2.1e+143: tmp = t_2 + (z * ((x * y) - (b * c))) else: tmp = t_1 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)))) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (b <= -3.2e+62) tmp = t_1; elseif (b <= -2.1e-55) tmp = Float64(t_2 + Float64(a * Float64(b * i))); elseif (b <= -4.7e-241) tmp = Float64(z * Float64(Float64(x * y) + Float64(t * Float64(Float64(Float64(c * j) - Float64(x * a)) / z)))); elseif (b <= 2.1e+143) tmp = Float64(t_2 + Float64(z * Float64(Float64(x * y) - Float64(b * c)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (b <= -3.2e+62) tmp = t_1; elseif (b <= -2.1e-55) tmp = t_2 + (a * (b * i)); elseif (b <= -4.7e-241) tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z))); elseif (b <= 2.1e+143) tmp = t_2 + (z * ((x * y) - (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[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.2e+62], t$95$1, If[LessEqual[b, -2.1e-55], N[(t$95$2 + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -4.7e-241], N[(z * N[(N[(x * y), $MachinePrecision] + N[(t * N[(N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.1e+143], N[(t$95$2 + N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\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)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;b \leq -3.2 \cdot 10^{+62}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -2.1 \cdot 10^{-55}:\\
\;\;\;\;t\_2 + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;b \leq -4.7 \cdot 10^{-241}:\\
\;\;\;\;z \cdot \left(x \cdot y + t \cdot \frac{c \cdot j - x \cdot a}{z}\right)\\
\mathbf{elif}\;b \leq 2.1 \cdot 10^{+143}:\\
\;\;\;\;t\_2 + z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -3.19999999999999984e62 or 2.09999999999999988e143 < b Initial program 69.7%
+-commutative69.7%
fma-define72.0%
*-commutative72.0%
*-commutative72.0%
cancel-sign-sub-inv72.0%
cancel-sign-sub72.0%
fma-neg73.1%
distribute-rgt-neg-out73.1%
remove-double-neg73.1%
*-commutative73.1%
*-commutative73.1%
Simplified73.1%
Taylor expanded in y around 0 69.9%
*-commutative69.9%
*-commutative69.9%
associate-*r*69.8%
*-commutative69.8%
associate-*r*69.8%
*-commutative69.8%
*-commutative69.8%
associate-*r*67.5%
*-commutative67.5%
associate-*r*70.9%
distribute-lft-in70.9%
+-commutative70.9%
mul-1-neg70.9%
unsub-neg70.9%
*-commutative70.9%
*-commutative70.9%
Simplified70.9%
Taylor expanded in c around inf 70.8%
if -3.19999999999999984e62 < b < -2.1000000000000002e-55Initial program 71.5%
cancel-sign-sub-inv71.5%
cancel-sign-sub71.5%
*-commutative71.5%
fma-neg74.8%
distribute-rgt-neg-in74.8%
remove-double-neg74.8%
*-commutative74.8%
*-commutative74.8%
sub-neg74.8%
sub-neg74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in i around inf 74.8%
if -2.1000000000000002e-55 < b < -4.6999999999999999e-241Initial program 85.0%
+-commutative85.0%
fma-define85.0%
*-commutative85.0%
*-commutative85.0%
cancel-sign-sub-inv85.0%
cancel-sign-sub85.0%
fma-neg85.0%
distribute-rgt-neg-out85.0%
remove-double-neg85.0%
*-commutative85.0%
*-commutative85.0%
Simplified85.0%
Taylor expanded in t around -inf 74.8%
Simplified76.9%
Taylor expanded in x around inf 76.8%
Taylor expanded in z around inf 81.1%
+-commutative81.1%
mul-1-neg81.1%
unsub-neg81.1%
*-commutative81.1%
associate-/l*79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
if -4.6999999999999999e-241 < b < 2.09999999999999988e143Initial program 70.3%
cancel-sign-sub-inv70.3%
cancel-sign-sub70.3%
*-commutative70.3%
fma-neg70.3%
distribute-rgt-neg-in70.3%
remove-double-neg70.3%
*-commutative70.3%
*-commutative70.3%
sub-neg70.3%
sub-neg70.3%
*-commutative70.3%
*-commutative70.3%
Simplified70.3%
Taylor expanded in z around inf 71.3%
Final simplification72.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -1.22e+189)
(+ (* t (* c j)) t_1)
(if (<= b -7.8e-203)
(+ (+ (* x (- (* y z) (* t a))) t_1) (* i (/ (* c (* t j)) i)))
(if (<= b 2e-30)
(+ (* a (- (* b i) (* x t))) (* j (- (* t c) (* y i))))
(+ (* t (- (* c j) (* x a))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -1.22e+189) {
tmp = (t * (c * j)) + t_1;
} else if (b <= -7.8e-203) {
tmp = ((x * ((y * z) - (t * a))) + t_1) + (i * ((c * (t * j)) / i));
} else if (b <= 2e-30) {
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)));
} else {
tmp = (t * ((c * j) - (x * a))) + 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) - (z * c))
if (b <= (-1.22d+189)) then
tmp = (t * (c * j)) + t_1
else if (b <= (-7.8d-203)) then
tmp = ((x * ((y * z) - (t * a))) + t_1) + (i * ((c * (t * j)) / i))
else if (b <= 2d-30) then
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)))
else
tmp = (t * ((c * j) - (x * a))) + 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) - (z * c));
double tmp;
if (b <= -1.22e+189) {
tmp = (t * (c * j)) + t_1;
} else if (b <= -7.8e-203) {
tmp = ((x * ((y * z) - (t * a))) + t_1) + (i * ((c * (t * j)) / i));
} else if (b <= 2e-30) {
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)));
} else {
tmp = (t * ((c * j) - (x * a))) + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -1.22e+189: tmp = (t * (c * j)) + t_1 elif b <= -7.8e-203: tmp = ((x * ((y * z) - (t * a))) + t_1) + (i * ((c * (t * j)) / i)) elif b <= 2e-30: tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i))) else: tmp = (t * ((c * j) - (x * a))) + t_1 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 (b <= -1.22e+189) tmp = Float64(Float64(t * Float64(c * j)) + t_1); elseif (b <= -7.8e-203) tmp = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1) + Float64(i * Float64(Float64(c * Float64(t * j)) / i))); elseif (b <= 2e-30) tmp = Float64(Float64(a * Float64(Float64(b * i) - Float64(x * t))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); else tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + t_1); 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 (b <= -1.22e+189) tmp = (t * (c * j)) + t_1; elseif (b <= -7.8e-203) tmp = ((x * ((y * z) - (t * a))) + t_1) + (i * ((c * (t * j)) / i)); elseif (b <= 2e-30) tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i))); else tmp = (t * ((c * j) - (x * a))) + t_1; 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[b, -1.22e+189], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, -7.8e-203], N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + N[(i * N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] / i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2e-30], N[(N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -1.22 \cdot 10^{+189}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + t\_1\\
\mathbf{elif}\;b \leq -7.8 \cdot 10^{-203}:\\
\;\;\;\;\left(x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\right) + i \cdot \frac{c \cdot \left(t \cdot j\right)}{i}\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-30}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + t\_1\\
\end{array}
\end{array}
if b < -1.2200000000000001e189Initial program 59.9%
+-commutative59.9%
fma-define59.9%
*-commutative59.9%
*-commutative59.9%
cancel-sign-sub-inv59.9%
cancel-sign-sub59.9%
fma-neg63.3%
distribute-rgt-neg-out63.3%
remove-double-neg63.3%
*-commutative63.3%
*-commutative63.3%
Simplified63.3%
Taylor expanded in y around 0 61.9%
*-commutative61.9%
*-commutative61.9%
associate-*r*58.5%
*-commutative58.5%
associate-*r*58.5%
*-commutative58.5%
*-commutative58.5%
associate-*r*55.2%
*-commutative55.2%
associate-*r*58.5%
distribute-lft-in58.5%
+-commutative58.5%
mul-1-neg58.5%
unsub-neg58.5%
*-commutative58.5%
*-commutative58.5%
Simplified58.5%
Taylor expanded in c around inf 71.9%
if -1.2200000000000001e189 < b < -7.7999999999999998e-203Initial program 79.2%
Taylor expanded in i around inf 78.3%
+-commutative78.3%
mul-1-neg78.3%
unsub-neg78.3%
associate-/l*78.4%
*-commutative78.4%
*-commutative78.4%
Simplified78.4%
Taylor expanded in c around inf 76.3%
if -7.7999999999999998e-203 < b < 2e-30Initial program 77.1%
cancel-sign-sub-inv77.1%
cancel-sign-sub77.1%
*-commutative77.1%
fma-neg77.1%
distribute-rgt-neg-in77.1%
remove-double-neg77.1%
*-commutative77.1%
*-commutative77.1%
sub-neg77.1%
sub-neg77.1%
*-commutative77.1%
*-commutative77.1%
Simplified77.1%
Taylor expanded in a around -inf 78.0%
if 2e-30 < b Initial program 63.4%
+-commutative63.4%
fma-define65.2%
*-commutative65.2%
*-commutative65.2%
cancel-sign-sub-inv65.2%
cancel-sign-sub65.2%
fma-neg65.1%
distribute-rgt-neg-out65.1%
remove-double-neg65.1%
*-commutative65.1%
*-commutative65.1%
Simplified65.1%
Taylor expanded in y around 0 72.5%
*-commutative72.5%
*-commutative72.5%
associate-*r*75.9%
*-commutative75.9%
associate-*r*75.9%
*-commutative75.9%
*-commutative75.9%
associate-*r*74.2%
*-commutative74.2%
associate-*r*79.4%
distribute-lft-in79.4%
+-commutative79.4%
mul-1-neg79.4%
unsub-neg79.4%
*-commutative79.4%
*-commutative79.4%
Simplified79.4%
Final simplification76.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* t (* c j)) (* b (- (* a i) (* z c)))))
(t_2 (* j (- (* t c) (* y i)))))
(if (<= b -5.6e+63)
t_1
(if (<= b -2.9e-65)
(+ t_2 (* a (* b i)))
(if (<= b -3.3e-231)
(* z (+ (* x y) (* t (/ (- (* c j) (* x a)) z))))
(if (<= b 4.8e+120) (- t_2 (* 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 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (b <= -5.6e+63) {
tmp = t_1;
} else if (b <= -2.9e-65) {
tmp = t_2 + (a * (b * i));
} else if (b <= -3.3e-231) {
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)));
} else if (b <= 4.8e+120) {
tmp = t_2 - (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) :: t_2
real(8) :: tmp
t_1 = (t * (c * j)) + (b * ((a * i) - (z * c)))
t_2 = j * ((t * c) - (y * i))
if (b <= (-5.6d+63)) then
tmp = t_1
else if (b <= (-2.9d-65)) then
tmp = t_2 + (a * (b * i))
else if (b <= (-3.3d-231)) then
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)))
else if (b <= 4.8d+120) then
tmp = t_2 - (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 = (t * (c * j)) + (b * ((a * i) - (z * c)));
double t_2 = j * ((t * c) - (y * i));
double tmp;
if (b <= -5.6e+63) {
tmp = t_1;
} else if (b <= -2.9e-65) {
tmp = t_2 + (a * (b * i));
} else if (b <= -3.3e-231) {
tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z)));
} else if (b <= 4.8e+120) {
tmp = t_2 - (z * (b * c));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))) t_2 = j * ((t * c) - (y * i)) tmp = 0 if b <= -5.6e+63: tmp = t_1 elif b <= -2.9e-65: tmp = t_2 + (a * (b * i)) elif b <= -3.3e-231: tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z))) elif b <= 4.8e+120: tmp = t_2 - (z * (b * c)) else: tmp = t_1 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)))) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (b <= -5.6e+63) tmp = t_1; elseif (b <= -2.9e-65) tmp = Float64(t_2 + Float64(a * Float64(b * i))); elseif (b <= -3.3e-231) tmp = Float64(z * Float64(Float64(x * y) + Float64(t * Float64(Float64(Float64(c * j) - Float64(x * a)) / z)))); elseif (b <= 4.8e+120) tmp = Float64(t_2 - Float64(z * Float64(b * c))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (t * (c * j)) + (b * ((a * i) - (z * c))); t_2 = j * ((t * c) - (y * i)); tmp = 0.0; if (b <= -5.6e+63) tmp = t_1; elseif (b <= -2.9e-65) tmp = t_2 + (a * (b * i)); elseif (b <= -3.3e-231) tmp = z * ((x * y) + (t * (((c * j) - (x * a)) / z))); elseif (b <= 4.8e+120) tmp = t_2 - (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[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.6e+63], t$95$1, If[LessEqual[b, -2.9e-65], N[(t$95$2 + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -3.3e-231], N[(z * N[(N[(x * y), $MachinePrecision] + N[(t * N[(N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.8e+120], N[(t$95$2 - N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\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)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;b \leq -5.6 \cdot 10^{+63}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -2.9 \cdot 10^{-65}:\\
\;\;\;\;t\_2 + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;b \leq -3.3 \cdot 10^{-231}:\\
\;\;\;\;z \cdot \left(x \cdot y + t \cdot \frac{c \cdot j - x \cdot a}{z}\right)\\
\mathbf{elif}\;b \leq 4.8 \cdot 10^{+120}:\\
\;\;\;\;t\_2 - z \cdot \left(b \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.59999999999999974e63 or 4.80000000000000002e120 < b Initial program 69.2%
+-commutative69.2%
fma-define71.5%
*-commutative71.5%
*-commutative71.5%
cancel-sign-sub-inv71.5%
cancel-sign-sub71.5%
fma-neg72.6%
distribute-rgt-neg-out72.6%
remove-double-neg72.6%
*-commutative72.6%
*-commutative72.6%
Simplified72.6%
Taylor expanded in y around 0 68.3%
*-commutative68.3%
*-commutative68.3%
associate-*r*68.2%
*-commutative68.2%
associate-*r*68.2%
*-commutative68.2%
*-commutative68.2%
associate-*r*65.9%
*-commutative65.9%
associate-*r*69.3%
distribute-lft-in69.3%
+-commutative69.3%
mul-1-neg69.3%
unsub-neg69.3%
*-commutative69.3%
*-commutative69.3%
Simplified69.3%
Taylor expanded in c around inf 70.4%
if -5.59999999999999974e63 < b < -2.8999999999999998e-65Initial program 71.5%
cancel-sign-sub-inv71.5%
cancel-sign-sub71.5%
*-commutative71.5%
fma-neg74.8%
distribute-rgt-neg-in74.8%
remove-double-neg74.8%
*-commutative74.8%
*-commutative74.8%
sub-neg74.8%
sub-neg74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in i around inf 74.8%
if -2.8999999999999998e-65 < b < -3.30000000000000028e-231Initial program 86.6%
+-commutative86.6%
fma-define86.6%
*-commutative86.6%
*-commutative86.6%
cancel-sign-sub-inv86.6%
cancel-sign-sub86.6%
fma-neg86.6%
distribute-rgt-neg-out86.6%
remove-double-neg86.6%
*-commutative86.6%
*-commutative86.6%
Simplified86.6%
Taylor expanded in t around -inf 76.0%
Simplified78.1%
Taylor expanded in x around inf 78.1%
Taylor expanded in z around inf 80.2%
+-commutative80.2%
mul-1-neg80.2%
unsub-neg80.2%
*-commutative80.2%
associate-/l*78.1%
*-commutative78.1%
*-commutative78.1%
Simplified78.1%
if -3.30000000000000028e-231 < b < 4.80000000000000002e120Initial program 70.3%
cancel-sign-sub-inv70.3%
cancel-sign-sub70.3%
*-commutative70.3%
fma-neg70.3%
distribute-rgt-neg-in70.3%
remove-double-neg70.3%
*-commutative70.3%
*-commutative70.3%
sub-neg70.3%
sub-neg70.3%
*-commutative70.3%
*-commutative70.3%
Simplified70.3%
Taylor expanded in c around inf 65.8%
mul-1-neg65.8%
*-commutative65.8%
*-commutative65.8%
associate-*r*69.0%
*-commutative69.0%
distribute-rgt-neg-out69.0%
distribute-rgt-neg-in69.0%
Simplified69.0%
Final simplification71.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -7e+198)
(+ (* t (* c j)) t_1)
(if (or (<= b -1.6e-179) (not (<= b 8e+133)))
(+ (* x (- (* y z) (* t a))) t_1)
(+ (* j (- (* t c) (* y i))) (* 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 = b * ((a * i) - (z * c));
double tmp;
if (b <= -7e+198) {
tmp = (t * (c * j)) + t_1;
} else if ((b <= -1.6e-179) || !(b <= 8e+133)) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else {
tmp = (j * ((t * c) - (y * i))) + (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 = b * ((a * i) - (z * c))
if (b <= (-7d+198)) then
tmp = (t * (c * j)) + t_1
else if ((b <= (-1.6d-179)) .or. (.not. (b <= 8d+133))) then
tmp = (x * ((y * z) - (t * a))) + t_1
else
tmp = (j * ((t * c) - (y * i))) + (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 = b * ((a * i) - (z * c));
double tmp;
if (b <= -7e+198) {
tmp = (t * (c * j)) + t_1;
} else if ((b <= -1.6e-179) || !(b <= 8e+133)) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else {
tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -7e+198: tmp = (t * (c * j)) + t_1 elif (b <= -1.6e-179) or not (b <= 8e+133): tmp = (x * ((y * z) - (t * a))) + t_1 else: tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c))) 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 (b <= -7e+198) tmp = Float64(Float64(t * Float64(c * j)) + t_1); elseif ((b <= -1.6e-179) || !(b <= 8e+133)) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1); else tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + 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 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -7e+198) tmp = (t * (c * j)) + t_1; elseif ((b <= -1.6e-179) || ~((b <= 8e+133))) tmp = (x * ((y * z) - (t * a))) + t_1; else tmp = (j * ((t * c) - (y * i))) + (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[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -7e+198], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[Or[LessEqual[b, -1.6e-179], N[Not[LessEqual[b, 8e+133]], $MachinePrecision]], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -7 \cdot 10^{+198}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + t\_1\\
\mathbf{elif}\;b \leq -1.6 \cdot 10^{-179} \lor \neg \left(b \leq 8 \cdot 10^{+133}\right):\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if b < -7.00000000000000026e198Initial program 59.9%
+-commutative59.9%
fma-define59.9%
*-commutative59.9%
*-commutative59.9%
cancel-sign-sub-inv59.9%
cancel-sign-sub59.9%
fma-neg63.3%
distribute-rgt-neg-out63.3%
remove-double-neg63.3%
*-commutative63.3%
*-commutative63.3%
Simplified63.3%
Taylor expanded in y around 0 61.9%
*-commutative61.9%
*-commutative61.9%
associate-*r*58.5%
*-commutative58.5%
associate-*r*58.5%
*-commutative58.5%
*-commutative58.5%
associate-*r*55.2%
*-commutative55.2%
associate-*r*58.5%
distribute-lft-in58.5%
+-commutative58.5%
mul-1-neg58.5%
unsub-neg58.5%
*-commutative58.5%
*-commutative58.5%
Simplified58.5%
Taylor expanded in c around inf 71.9%
if -7.00000000000000026e198 < b < -1.6e-179 or 8.0000000000000002e133 < b Initial program 76.7%
Taylor expanded in j around 0 79.2%
if -1.6e-179 < b < 8.0000000000000002e133Initial program 72.3%
cancel-sign-sub-inv72.3%
cancel-sign-sub72.3%
*-commutative72.3%
fma-neg72.3%
distribute-rgt-neg-in72.3%
remove-double-neg72.3%
*-commutative72.3%
*-commutative72.3%
sub-neg72.3%
sub-neg72.3%
*-commutative72.3%
*-commutative72.3%
Simplified72.3%
Taylor expanded in z around inf 71.4%
Final simplification75.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -1.55e+195)
(+ (* t (* c j)) t_1)
(if (<= b -3.8e-158)
(+ (* x (- (* y z) (* t a))) t_1)
(if (<= b 2e-30)
(+ (* a (- (* b i) (* x t))) (* j (- (* t c) (* y i))))
(+ (* t (- (* c j) (* x a))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -1.55e+195) {
tmp = (t * (c * j)) + t_1;
} else if (b <= -3.8e-158) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else if (b <= 2e-30) {
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)));
} else {
tmp = (t * ((c * j) - (x * a))) + 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) - (z * c))
if (b <= (-1.55d+195)) then
tmp = (t * (c * j)) + t_1
else if (b <= (-3.8d-158)) then
tmp = (x * ((y * z) - (t * a))) + t_1
else if (b <= 2d-30) then
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)))
else
tmp = (t * ((c * j) - (x * a))) + 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) - (z * c));
double tmp;
if (b <= -1.55e+195) {
tmp = (t * (c * j)) + t_1;
} else if (b <= -3.8e-158) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else if (b <= 2e-30) {
tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i)));
} else {
tmp = (t * ((c * j) - (x * a))) + t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -1.55e+195: tmp = (t * (c * j)) + t_1 elif b <= -3.8e-158: tmp = (x * ((y * z) - (t * a))) + t_1 elif b <= 2e-30: tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i))) else: tmp = (t * ((c * j) - (x * a))) + t_1 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 (b <= -1.55e+195) tmp = Float64(Float64(t * Float64(c * j)) + t_1); elseif (b <= -3.8e-158) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1); elseif (b <= 2e-30) tmp = Float64(Float64(a * Float64(Float64(b * i) - Float64(x * t))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); else tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + t_1); 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 (b <= -1.55e+195) tmp = (t * (c * j)) + t_1; elseif (b <= -3.8e-158) tmp = (x * ((y * z) - (t * a))) + t_1; elseif (b <= 2e-30) tmp = (a * ((b * i) - (x * t))) + (j * ((t * c) - (y * i))); else tmp = (t * ((c * j) - (x * a))) + t_1; 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[b, -1.55e+195], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, -3.8e-158], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, 2e-30], N[(N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -1.55 \cdot 10^{+195}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + t\_1\\
\mathbf{elif}\;b \leq -3.8 \cdot 10^{-158}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\\
\mathbf{elif}\;b \leq 2 \cdot 10^{-30}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + t\_1\\
\end{array}
\end{array}
if b < -1.5500000000000001e195Initial program 59.9%
+-commutative59.9%
fma-define59.9%
*-commutative59.9%
*-commutative59.9%
cancel-sign-sub-inv59.9%
cancel-sign-sub59.9%
fma-neg63.3%
distribute-rgt-neg-out63.3%
remove-double-neg63.3%
*-commutative63.3%
*-commutative63.3%
Simplified63.3%
Taylor expanded in y around 0 61.9%
*-commutative61.9%
*-commutative61.9%
associate-*r*58.5%
*-commutative58.5%
associate-*r*58.5%
*-commutative58.5%
*-commutative58.5%
associate-*r*55.2%
*-commutative55.2%
associate-*r*58.5%
distribute-lft-in58.5%
+-commutative58.5%
mul-1-neg58.5%
unsub-neg58.5%
*-commutative58.5%
*-commutative58.5%
Simplified58.5%
Taylor expanded in c around inf 71.9%
if -1.5500000000000001e195 < b < -3.7999999999999999e-158Initial program 78.1%
Taylor expanded in j around 0 74.7%
if -3.7999999999999999e-158 < b < 2e-30Initial program 78.7%
cancel-sign-sub-inv78.7%
cancel-sign-sub78.7%
*-commutative78.7%
fma-neg78.7%
distribute-rgt-neg-in78.7%
remove-double-neg78.7%
*-commutative78.7%
*-commutative78.7%
sub-neg78.7%
sub-neg78.7%
*-commutative78.7%
*-commutative78.7%
Simplified78.7%
Taylor expanded in a around -inf 76.0%
if 2e-30 < b Initial program 63.4%
+-commutative63.4%
fma-define65.2%
*-commutative65.2%
*-commutative65.2%
cancel-sign-sub-inv65.2%
cancel-sign-sub65.2%
fma-neg65.1%
distribute-rgt-neg-out65.1%
remove-double-neg65.1%
*-commutative65.1%
*-commutative65.1%
Simplified65.1%
Taylor expanded in y around 0 72.5%
*-commutative72.5%
*-commutative72.5%
associate-*r*75.9%
*-commutative75.9%
associate-*r*75.9%
*-commutative75.9%
*-commutative75.9%
associate-*r*74.2%
*-commutative74.2%
associate-*r*79.4%
distribute-lft-in79.4%
+-commutative79.4%
mul-1-neg79.4%
unsub-neg79.4%
*-commutative79.4%
*-commutative79.4%
Simplified79.4%
Final simplification75.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -1.2e+60)
(* x (- (* y z) (* t a)))
(if (<= x -7.2e-192)
(+ (* j (- (* t c) (* y i))) (* a (* b i)))
(if (<= x 9.2e+17)
(+ (* t (* c j)) (* b (- (* a i) (* z c))))
(* x (* a (- (/ (* y z) a) t)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.2e+60) {
tmp = x * ((y * z) - (t * a));
} else if (x <= -7.2e-192) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else if (x <= 9.2e+17) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else {
tmp = x * (a * (((y * z) / a) - t));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-1.2d+60)) then
tmp = x * ((y * z) - (t * a))
else if (x <= (-7.2d-192)) then
tmp = (j * ((t * c) - (y * i))) + (a * (b * i))
else if (x <= 9.2d+17) then
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)))
else
tmp = x * (a * (((y * z) / a) - t))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.2e+60) {
tmp = x * ((y * z) - (t * a));
} else if (x <= -7.2e-192) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else if (x <= 9.2e+17) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} else {
tmp = x * (a * (((y * z) / a) - t));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -1.2e+60: tmp = x * ((y * z) - (t * a)) elif x <= -7.2e-192: tmp = (j * ((t * c) - (y * i))) + (a * (b * i)) elif x <= 9.2e+17: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) else: tmp = x * (a * (((y * z) / a) - t)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -1.2e+60) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (x <= -7.2e-192) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(a * Float64(b * i))); elseif (x <= 9.2e+17) tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(x * Float64(a * Float64(Float64(Float64(y * z) / a) - t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -1.2e+60) tmp = x * ((y * z) - (t * a)); elseif (x <= -7.2e-192) tmp = (j * ((t * c) - (y * i))) + (a * (b * i)); elseif (x <= 9.2e+17) tmp = (t * (c * j)) + (b * ((a * i) - (z * c))); else tmp = x * (a * (((y * z) / a) - t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -1.2e+60], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.2e-192], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.2e+17], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(a * N[(N[(N[(y * z), $MachinePrecision] / a), $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{+60}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;x \leq -7.2 \cdot 10^{-192}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;x \leq 9.2 \cdot 10^{+17}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(a \cdot \left(\frac{y \cdot z}{a} - t\right)\right)\\
\end{array}
\end{array}
if x < -1.2e60Initial program 77.0%
Taylor expanded in j around 0 74.0%
Taylor expanded in x around inf 69.4%
*-commutative69.4%
Simplified69.4%
if -1.2e60 < x < -7.1999999999999998e-192Initial program 76.1%
cancel-sign-sub-inv76.1%
cancel-sign-sub76.1%
*-commutative76.1%
fma-neg76.1%
distribute-rgt-neg-in76.1%
remove-double-neg76.1%
*-commutative76.1%
*-commutative76.1%
sub-neg76.1%
sub-neg76.1%
*-commutative76.1%
*-commutative76.1%
Simplified76.1%
Taylor expanded in i around inf 65.3%
if -7.1999999999999998e-192 < x < 9.2e17Initial program 67.1%
+-commutative67.1%
fma-define67.1%
*-commutative67.1%
*-commutative67.1%
cancel-sign-sub-inv67.1%
cancel-sign-sub67.1%
fma-neg69.3%
distribute-rgt-neg-out69.3%
remove-double-neg69.3%
*-commutative69.3%
*-commutative69.3%
Simplified69.3%
Taylor expanded in y around 0 73.6%
*-commutative73.6%
*-commutative73.6%
associate-*r*73.6%
*-commutative73.6%
associate-*r*73.6%
*-commutative73.6%
*-commutative73.6%
associate-*r*70.1%
*-commutative70.1%
associate-*r*75.6%
distribute-lft-in75.6%
+-commutative75.6%
mul-1-neg75.6%
unsub-neg75.6%
*-commutative75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in c around inf 73.3%
if 9.2e17 < x Initial program 74.9%
Taylor expanded in j around 0 69.3%
Taylor expanded in x around inf 69.7%
*-commutative69.7%
Simplified69.7%
Taylor expanded in a around inf 69.7%
Final simplification70.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))) (t_2 (* b (- (* a i) (* z c)))))
(if (<= b -3.7e+63)
t_2
(if (<= b -1.25e-40)
t_1
(if (<= b -3.2e-223) (* t (* x (- a))) (if (<= b 4.3e+120) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -3.7e+63) {
tmp = t_2;
} else if (b <= -1.25e-40) {
tmp = t_1;
} else if (b <= -3.2e-223) {
tmp = t * (x * -a);
} else if (b <= 4.3e+120) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = j * ((t * c) - (y * i))
t_2 = b * ((a * i) - (z * c))
if (b <= (-3.7d+63)) then
tmp = t_2
else if (b <= (-1.25d-40)) then
tmp = t_1
else if (b <= (-3.2d-223)) then
tmp = t * (x * -a)
else if (b <= 4.3d+120) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -3.7e+63) {
tmp = t_2;
} else if (b <= -1.25e-40) {
tmp = t_1;
} else if (b <= -3.2e-223) {
tmp = t * (x * -a);
} else if (b <= 4.3e+120) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) t_2 = b * ((a * i) - (z * c)) tmp = 0 if b <= -3.7e+63: tmp = t_2 elif b <= -1.25e-40: tmp = t_1 elif b <= -3.2e-223: tmp = t * (x * -a) elif b <= 4.3e+120: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -3.7e+63) tmp = t_2; elseif (b <= -1.25e-40) tmp = t_1; elseif (b <= -3.2e-223) tmp = Float64(t * Float64(x * Float64(-a))); elseif (b <= 4.3e+120) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((t * c) - (y * i)); t_2 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -3.7e+63) tmp = t_2; elseif (b <= -1.25e-40) tmp = t_1; elseif (b <= -3.2e-223) tmp = t * (x * -a); elseif (b <= 4.3e+120) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.7e+63], t$95$2, If[LessEqual[b, -1.25e-40], t$95$1, If[LessEqual[b, -3.2e-223], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.3e+120], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -3.7 \cdot 10^{+63}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -1.25 \cdot 10^{-40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -3.2 \cdot 10^{-223}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;b \leq 4.3 \cdot 10^{+120}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -3.69999999999999968e63 or 4.3000000000000002e120 < b Initial program 69.2%
Taylor expanded in y around inf 68.1%
mul-1-neg68.1%
unsub-neg68.1%
associate-/l*67.0%
Simplified67.0%
Taylor expanded in b around inf 67.0%
*-commutative67.0%
Simplified67.0%
if -3.69999999999999968e63 < b < -1.24999999999999991e-40 or -3.2000000000000001e-223 < b < 4.3000000000000002e120Initial program 70.2%
+-commutative70.2%
fma-define72.7%
*-commutative72.7%
*-commutative72.7%
cancel-sign-sub-inv72.7%
cancel-sign-sub72.7%
fma-neg73.5%
distribute-rgt-neg-out73.5%
remove-double-neg73.5%
*-commutative73.5%
*-commutative73.5%
Simplified73.5%
Taylor expanded in j around inf 64.4%
sub-neg64.4%
*-commutative64.4%
*-commutative64.4%
sub-neg64.4%
Simplified64.4%
if -1.24999999999999991e-40 < b < -3.2000000000000001e-223Initial program 86.1%
+-commutative86.1%
fma-define86.1%
*-commutative86.1%
*-commutative86.1%
cancel-sign-sub-inv86.1%
cancel-sign-sub86.1%
fma-neg86.1%
distribute-rgt-neg-out86.1%
remove-double-neg86.1%
*-commutative86.1%
*-commutative86.1%
Simplified86.1%
Taylor expanded in t around -inf 72.4%
Simplified74.4%
Taylor expanded in x around inf 72.2%
Taylor expanded in a around inf 47.0%
*-commutative47.0%
Simplified47.0%
Final simplification62.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -5.6e-86)
t_1
(if (<= b -8.2e-234)
(* t (* x (- a)))
(if (<= b 1.75e+112) (* c (- (* t j) (* z b))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -5.6e-86) {
tmp = t_1;
} else if (b <= -8.2e-234) {
tmp = t * (x * -a);
} else if (b <= 1.75e+112) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (b <= (-5.6d-86)) then
tmp = t_1
else if (b <= (-8.2d-234)) then
tmp = t * (x * -a)
else if (b <= 1.75d+112) then
tmp = c * ((t * j) - (z * b))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -5.6e-86) {
tmp = t_1;
} else if (b <= -8.2e-234) {
tmp = t * (x * -a);
} else if (b <= 1.75e+112) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -5.6e-86: tmp = t_1 elif b <= -8.2e-234: tmp = t * (x * -a) elif b <= 1.75e+112: tmp = c * ((t * j) - (z * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -5.6e-86) tmp = t_1; elseif (b <= -8.2e-234) tmp = Float64(t * Float64(x * Float64(-a))); elseif (b <= 1.75e+112) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -5.6e-86) tmp = t_1; elseif (b <= -8.2e-234) tmp = t * (x * -a); elseif (b <= 1.75e+112) tmp = c * ((t * j) - (z * b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5.6e-86], t$95$1, If[LessEqual[b, -8.2e-234], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.75e+112], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -5.6 \cdot 10^{-86}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -8.2 \cdot 10^{-234}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;b \leq 1.75 \cdot 10^{+112}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -5.60000000000000019e-86 or 1.74999999999999998e112 < b Initial program 70.0%
Taylor expanded in y around inf 69.2%
mul-1-neg69.2%
unsub-neg69.2%
associate-/l*69.2%
Simplified69.2%
Taylor expanded in b around inf 60.6%
*-commutative60.6%
Simplified60.6%
if -5.60000000000000019e-86 < b < -8.20000000000000021e-234Initial program 86.3%
+-commutative86.3%
fma-define86.3%
*-commutative86.3%
*-commutative86.3%
cancel-sign-sub-inv86.3%
cancel-sign-sub86.3%
fma-neg86.3%
distribute-rgt-neg-out86.3%
remove-double-neg86.3%
*-commutative86.3%
*-commutative86.3%
Simplified86.3%
Taylor expanded in t around -inf 77.6%
Simplified79.8%
Taylor expanded in x around inf 79.9%
Taylor expanded in a around inf 52.5%
*-commutative52.5%
Simplified52.5%
if -8.20000000000000021e-234 < b < 1.74999999999999998e112Initial program 70.4%
+-commutative70.4%
fma-define71.5%
*-commutative71.5%
*-commutative71.5%
cancel-sign-sub-inv71.5%
cancel-sign-sub71.5%
fma-neg71.5%
distribute-rgt-neg-out71.5%
remove-double-neg71.5%
*-commutative71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in c around inf 42.5%
*-commutative42.5%
*-commutative42.5%
Simplified42.5%
Final simplification52.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -5e-78)
t_1
(if (<= b -7.6e-280)
(* t (* x (- a)))
(if (<= b 3.95e-22) (* i (* y (- j))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -5e-78) {
tmp = t_1;
} else if (b <= -7.6e-280) {
tmp = t * (x * -a);
} else if (b <= 3.95e-22) {
tmp = i * (y * -j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (b <= (-5d-78)) then
tmp = t_1
else if (b <= (-7.6d-280)) then
tmp = t * (x * -a)
else if (b <= 3.95d-22) then
tmp = i * (y * -j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -5e-78) {
tmp = t_1;
} else if (b <= -7.6e-280) {
tmp = t * (x * -a);
} else if (b <= 3.95e-22) {
tmp = i * (y * -j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -5e-78: tmp = t_1 elif b <= -7.6e-280: tmp = t * (x * -a) elif b <= 3.95e-22: tmp = i * (y * -j) else: tmp = t_1 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 (b <= -5e-78) tmp = t_1; elseif (b <= -7.6e-280) tmp = Float64(t * Float64(x * Float64(-a))); elseif (b <= 3.95e-22) tmp = Float64(i * Float64(y * Float64(-j))); 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) - (z * c)); tmp = 0.0; if (b <= -5e-78) tmp = t_1; elseif (b <= -7.6e-280) tmp = t * (x * -a); elseif (b <= 3.95e-22) tmp = i * (y * -j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -5e-78], t$95$1, If[LessEqual[b, -7.6e-280], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3.95e-22], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -5 \cdot 10^{-78}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -7.6 \cdot 10^{-280}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;b \leq 3.95 \cdot 10^{-22}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -4.9999999999999996e-78 or 3.9499999999999999e-22 < b Initial program 69.3%
Taylor expanded in y around inf 68.0%
mul-1-neg68.0%
unsub-neg68.0%
associate-/l*67.9%
Simplified67.9%
Taylor expanded in b around inf 55.7%
*-commutative55.7%
Simplified55.7%
if -4.9999999999999996e-78 < b < -7.6000000000000003e-280Initial program 83.1%
+-commutative83.1%
fma-define83.1%
*-commutative83.1%
*-commutative83.1%
cancel-sign-sub-inv83.1%
cancel-sign-sub83.1%
fma-neg83.1%
distribute-rgt-neg-out83.1%
remove-double-neg83.1%
*-commutative83.1%
*-commutative83.1%
Simplified83.1%
Taylor expanded in t around -inf 72.2%
Simplified74.0%
Taylor expanded in x around inf 75.9%
Taylor expanded in a around inf 49.4%
*-commutative49.4%
Simplified49.4%
if -7.6000000000000003e-280 < b < 3.9499999999999999e-22Initial program 73.0%
+-commutative73.0%
fma-define74.8%
*-commutative74.8%
*-commutative74.8%
cancel-sign-sub-inv74.8%
cancel-sign-sub74.8%
fma-neg74.8%
distribute-rgt-neg-out74.8%
remove-double-neg74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in i around inf 44.0%
distribute-lft-out--44.0%
*-commutative44.0%
Simplified44.0%
Taylor expanded in y around inf 40.5%
associate-*r*40.5%
neg-mul-140.5%
*-commutative40.5%
Simplified40.5%
Final simplification51.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -3.1e+51)
(* a (* b i))
(if (<= i -2.15e-120)
(* c (* t j))
(if (<= i 9.5e+46) (* t (* x (- a))) (* y (* i (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -3.1e+51) {
tmp = a * (b * i);
} else if (i <= -2.15e-120) {
tmp = c * (t * j);
} else if (i <= 9.5e+46) {
tmp = t * (x * -a);
} else {
tmp = y * (i * -j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-3.1d+51)) then
tmp = a * (b * i)
else if (i <= (-2.15d-120)) then
tmp = c * (t * j)
else if (i <= 9.5d+46) then
tmp = t * (x * -a)
else
tmp = y * (i * -j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -3.1e+51) {
tmp = a * (b * i);
} else if (i <= -2.15e-120) {
tmp = c * (t * j);
} else if (i <= 9.5e+46) {
tmp = t * (x * -a);
} else {
tmp = y * (i * -j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -3.1e+51: tmp = a * (b * i) elif i <= -2.15e-120: tmp = c * (t * j) elif i <= 9.5e+46: tmp = t * (x * -a) else: tmp = y * (i * -j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -3.1e+51) tmp = Float64(a * Float64(b * i)); elseif (i <= -2.15e-120) tmp = Float64(c * Float64(t * j)); elseif (i <= 9.5e+46) tmp = Float64(t * Float64(x * Float64(-a))); else tmp = Float64(y * Float64(i * Float64(-j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -3.1e+51) tmp = a * (b * i); elseif (i <= -2.15e-120) tmp = c * (t * j); elseif (i <= 9.5e+46) tmp = t * (x * -a); else tmp = y * (i * -j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -3.1e+51], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -2.15e-120], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 9.5e+46], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -3.1 \cdot 10^{+51}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq -2.15 \cdot 10^{-120}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;i \leq 9.5 \cdot 10^{+46}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -3.10000000000000011e51Initial program 65.7%
+-commutative65.7%
fma-define65.7%
*-commutative65.7%
*-commutative65.7%
cancel-sign-sub-inv65.7%
cancel-sign-sub65.7%
fma-neg67.5%
distribute-rgt-neg-out67.5%
remove-double-neg67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
Taylor expanded in i around inf 64.4%
distribute-lft-out--64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in y around 0 47.5%
if -3.10000000000000011e51 < i < -2.14999999999999991e-120Initial program 85.3%
+-commutative85.3%
fma-define87.7%
*-commutative87.7%
*-commutative87.7%
cancel-sign-sub-inv87.7%
cancel-sign-sub87.7%
fma-neg87.7%
distribute-rgt-neg-out87.7%
remove-double-neg87.7%
*-commutative87.7%
*-commutative87.7%
Simplified87.7%
Taylor expanded in c around inf 53.8%
*-commutative53.8%
*-commutative53.8%
Simplified53.8%
Taylor expanded in t around inf 44.3%
*-commutative44.3%
Simplified44.3%
if -2.14999999999999991e-120 < i < 9.5000000000000008e46Initial program 78.1%
+-commutative78.1%
fma-define81.0%
*-commutative81.0%
*-commutative81.0%
cancel-sign-sub-inv81.0%
cancel-sign-sub81.0%
fma-neg81.0%
distribute-rgt-neg-out81.0%
remove-double-neg81.0%
*-commutative81.0%
*-commutative81.0%
Simplified81.0%
Taylor expanded in t around -inf 63.5%
Simplified67.4%
Taylor expanded in x around inf 65.4%
Taylor expanded in a around inf 41.0%
*-commutative41.0%
Simplified41.0%
if 9.5000000000000008e46 < i Initial program 61.1%
+-commutative61.1%
fma-define62.9%
*-commutative62.9%
*-commutative62.9%
cancel-sign-sub-inv62.9%
cancel-sign-sub62.9%
fma-neg64.7%
distribute-rgt-neg-out64.7%
remove-double-neg64.7%
*-commutative64.7%
*-commutative64.7%
Simplified64.7%
Taylor expanded in i around inf 74.0%
distribute-lft-out--74.0%
*-commutative74.0%
Simplified74.0%
Taylor expanded in y around inf 42.5%
associate-*r*42.5%
neg-mul-142.5%
*-commutative42.5%
Simplified42.5%
Taylor expanded in i around 0 42.5%
neg-mul-142.5%
distribute-lft-neg-in42.5%
associate-*r*44.2%
*-commutative44.2%
Simplified44.2%
Final simplification43.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -4.2e+49)
(* a (* b i))
(if (<= i -2.2e-120)
(* c (* t j))
(if (<= i 2.4e+47) (* t (* x (- a))) (* i (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -4.2e+49) {
tmp = a * (b * i);
} else if (i <= -2.2e-120) {
tmp = c * (t * j);
} else if (i <= 2.4e+47) {
tmp = t * (x * -a);
} else {
tmp = i * (y * -j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-4.2d+49)) then
tmp = a * (b * i)
else if (i <= (-2.2d-120)) then
tmp = c * (t * j)
else if (i <= 2.4d+47) then
tmp = t * (x * -a)
else
tmp = i * (y * -j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -4.2e+49) {
tmp = a * (b * i);
} else if (i <= -2.2e-120) {
tmp = c * (t * j);
} else if (i <= 2.4e+47) {
tmp = t * (x * -a);
} else {
tmp = i * (y * -j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -4.2e+49: tmp = a * (b * i) elif i <= -2.2e-120: tmp = c * (t * j) elif i <= 2.4e+47: tmp = t * (x * -a) else: tmp = i * (y * -j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -4.2e+49) tmp = Float64(a * Float64(b * i)); elseif (i <= -2.2e-120) tmp = Float64(c * Float64(t * j)); elseif (i <= 2.4e+47) tmp = Float64(t * Float64(x * Float64(-a))); else tmp = Float64(i * Float64(y * Float64(-j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -4.2e+49) tmp = a * (b * i); elseif (i <= -2.2e-120) tmp = c * (t * j); elseif (i <= 2.4e+47) tmp = t * (x * -a); else tmp = i * (y * -j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -4.2e+49], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -2.2e-120], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.4e+47], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4.2 \cdot 10^{+49}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq -2.2 \cdot 10^{-120}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;i \leq 2.4 \cdot 10^{+47}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -4.20000000000000022e49Initial program 65.7%
+-commutative65.7%
fma-define65.7%
*-commutative65.7%
*-commutative65.7%
cancel-sign-sub-inv65.7%
cancel-sign-sub65.7%
fma-neg67.5%
distribute-rgt-neg-out67.5%
remove-double-neg67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
Taylor expanded in i around inf 64.4%
distribute-lft-out--64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in y around 0 47.5%
if -4.20000000000000022e49 < i < -2.20000000000000012e-120Initial program 85.3%
+-commutative85.3%
fma-define87.7%
*-commutative87.7%
*-commutative87.7%
cancel-sign-sub-inv87.7%
cancel-sign-sub87.7%
fma-neg87.7%
distribute-rgt-neg-out87.7%
remove-double-neg87.7%
*-commutative87.7%
*-commutative87.7%
Simplified87.7%
Taylor expanded in c around inf 53.8%
*-commutative53.8%
*-commutative53.8%
Simplified53.8%
Taylor expanded in t around inf 44.3%
*-commutative44.3%
Simplified44.3%
if -2.20000000000000012e-120 < i < 2.40000000000000019e47Initial program 78.1%
+-commutative78.1%
fma-define81.0%
*-commutative81.0%
*-commutative81.0%
cancel-sign-sub-inv81.0%
cancel-sign-sub81.0%
fma-neg81.0%
distribute-rgt-neg-out81.0%
remove-double-neg81.0%
*-commutative81.0%
*-commutative81.0%
Simplified81.0%
Taylor expanded in t around -inf 63.5%
Simplified67.4%
Taylor expanded in x around inf 65.4%
Taylor expanded in a around inf 41.0%
*-commutative41.0%
Simplified41.0%
if 2.40000000000000019e47 < i Initial program 61.1%
+-commutative61.1%
fma-define62.9%
*-commutative62.9%
*-commutative62.9%
cancel-sign-sub-inv62.9%
cancel-sign-sub62.9%
fma-neg64.7%
distribute-rgt-neg-out64.7%
remove-double-neg64.7%
*-commutative64.7%
*-commutative64.7%
Simplified64.7%
Taylor expanded in i around inf 74.0%
distribute-lft-out--74.0%
*-commutative74.0%
Simplified74.0%
Taylor expanded in y around inf 42.5%
associate-*r*42.5%
neg-mul-142.5%
*-commutative42.5%
Simplified42.5%
Final simplification43.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -5.9e+50)
(* a (* b i))
(if (<= i -2.1e-113)
(* c (* t j))
(if (<= i 1.45e+47) (* (* t a) (- x)) (* i (* y (- j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -5.9e+50) {
tmp = a * (b * i);
} else if (i <= -2.1e-113) {
tmp = c * (t * j);
} else if (i <= 1.45e+47) {
tmp = (t * a) * -x;
} else {
tmp = i * (y * -j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-5.9d+50)) then
tmp = a * (b * i)
else if (i <= (-2.1d-113)) then
tmp = c * (t * j)
else if (i <= 1.45d+47) then
tmp = (t * a) * -x
else
tmp = i * (y * -j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -5.9e+50) {
tmp = a * (b * i);
} else if (i <= -2.1e-113) {
tmp = c * (t * j);
} else if (i <= 1.45e+47) {
tmp = (t * a) * -x;
} else {
tmp = i * (y * -j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -5.9e+50: tmp = a * (b * i) elif i <= -2.1e-113: tmp = c * (t * j) elif i <= 1.45e+47: tmp = (t * a) * -x else: tmp = i * (y * -j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -5.9e+50) tmp = Float64(a * Float64(b * i)); elseif (i <= -2.1e-113) tmp = Float64(c * Float64(t * j)); elseif (i <= 1.45e+47) tmp = Float64(Float64(t * a) * Float64(-x)); else tmp = Float64(i * Float64(y * Float64(-j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -5.9e+50) tmp = a * (b * i); elseif (i <= -2.1e-113) tmp = c * (t * j); elseif (i <= 1.45e+47) tmp = (t * a) * -x; else tmp = i * (y * -j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -5.9e+50], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -2.1e-113], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.45e+47], N[(N[(t * a), $MachinePrecision] * (-x)), $MachinePrecision], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -5.9 \cdot 10^{+50}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq -2.1 \cdot 10^{-113}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;i \leq 1.45 \cdot 10^{+47}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\end{array}
\end{array}
if i < -5.8999999999999998e50Initial program 65.7%
+-commutative65.7%
fma-define65.7%
*-commutative65.7%
*-commutative65.7%
cancel-sign-sub-inv65.7%
cancel-sign-sub65.7%
fma-neg67.5%
distribute-rgt-neg-out67.5%
remove-double-neg67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
Taylor expanded in i around inf 64.4%
distribute-lft-out--64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in y around 0 47.5%
if -5.8999999999999998e50 < i < -2.1e-113Initial program 84.9%
+-commutative84.9%
fma-define87.4%
*-commutative87.4%
*-commutative87.4%
cancel-sign-sub-inv87.4%
cancel-sign-sub87.4%
fma-neg87.4%
distribute-rgt-neg-out87.4%
remove-double-neg87.4%
*-commutative87.4%
*-commutative87.4%
Simplified87.4%
Taylor expanded in c around inf 52.6%
*-commutative52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in t around inf 42.9%
*-commutative42.9%
Simplified42.9%
if -2.1e-113 < i < 1.4499999999999999e47Initial program 78.3%
Taylor expanded in j around 0 66.2%
Taylor expanded in x around inf 57.5%
*-commutative57.5%
Simplified57.5%
Taylor expanded in y around 0 39.8%
mul-1-neg39.8%
*-commutative39.8%
distribute-lft-neg-in39.8%
Simplified39.8%
if 1.4499999999999999e47 < i Initial program 61.1%
+-commutative61.1%
fma-define62.9%
*-commutative62.9%
*-commutative62.9%
cancel-sign-sub-inv62.9%
cancel-sign-sub62.9%
fma-neg64.7%
distribute-rgt-neg-out64.7%
remove-double-neg64.7%
*-commutative64.7%
*-commutative64.7%
Simplified64.7%
Taylor expanded in i around inf 74.0%
distribute-lft-out--74.0%
*-commutative74.0%
Simplified74.0%
Taylor expanded in y around inf 42.5%
associate-*r*42.5%
neg-mul-142.5%
*-commutative42.5%
Simplified42.5%
Final simplification42.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -6.5e+47)
(* a (* b i))
(if (<= i -3.2e-117)
(* c (* t j))
(if (<= i 7e+94) (* (* t a) (- x)) (* i (* a b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -6.5e+47) {
tmp = a * (b * i);
} else if (i <= -3.2e-117) {
tmp = c * (t * j);
} else if (i <= 7e+94) {
tmp = (t * a) * -x;
} else {
tmp = i * (a * b);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-6.5d+47)) then
tmp = a * (b * i)
else if (i <= (-3.2d-117)) then
tmp = c * (t * j)
else if (i <= 7d+94) then
tmp = (t * a) * -x
else
tmp = i * (a * b)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -6.5e+47) {
tmp = a * (b * i);
} else if (i <= -3.2e-117) {
tmp = c * (t * j);
} else if (i <= 7e+94) {
tmp = (t * a) * -x;
} else {
tmp = i * (a * b);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -6.5e+47: tmp = a * (b * i) elif i <= -3.2e-117: tmp = c * (t * j) elif i <= 7e+94: tmp = (t * a) * -x else: tmp = i * (a * b) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -6.5e+47) tmp = Float64(a * Float64(b * i)); elseif (i <= -3.2e-117) tmp = Float64(c * Float64(t * j)); elseif (i <= 7e+94) tmp = Float64(Float64(t * a) * Float64(-x)); else tmp = Float64(i * Float64(a * b)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -6.5e+47) tmp = a * (b * i); elseif (i <= -3.2e-117) tmp = c * (t * j); elseif (i <= 7e+94) tmp = (t * a) * -x; else tmp = i * (a * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -6.5e+47], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -3.2e-117], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 7e+94], N[(N[(t * a), $MachinePrecision] * (-x)), $MachinePrecision], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -6.5 \cdot 10^{+47}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq -3.2 \cdot 10^{-117}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;i \leq 7 \cdot 10^{+94}:\\
\;\;\;\;\left(t \cdot a\right) \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if i < -6.49999999999999988e47Initial program 65.7%
+-commutative65.7%
fma-define65.7%
*-commutative65.7%
*-commutative65.7%
cancel-sign-sub-inv65.7%
cancel-sign-sub65.7%
fma-neg67.5%
distribute-rgt-neg-out67.5%
remove-double-neg67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
Taylor expanded in i around inf 64.4%
distribute-lft-out--64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in y around 0 47.5%
if -6.49999999999999988e47 < i < -3.19999999999999995e-117Initial program 84.9%
+-commutative84.9%
fma-define87.4%
*-commutative87.4%
*-commutative87.4%
cancel-sign-sub-inv87.4%
cancel-sign-sub87.4%
fma-neg87.4%
distribute-rgt-neg-out87.4%
remove-double-neg87.4%
*-commutative87.4%
*-commutative87.4%
Simplified87.4%
Taylor expanded in c around inf 52.6%
*-commutative52.6%
*-commutative52.6%
Simplified52.6%
Taylor expanded in t around inf 42.9%
*-commutative42.9%
Simplified42.9%
if -3.19999999999999995e-117 < i < 6.9999999999999994e94Initial program 78.1%
Taylor expanded in j around 0 66.0%
Taylor expanded in x around inf 55.4%
*-commutative55.4%
Simplified55.4%
Taylor expanded in y around 0 38.0%
mul-1-neg38.0%
*-commutative38.0%
distribute-lft-neg-in38.0%
Simplified38.0%
if 6.9999999999999994e94 < i Initial program 58.8%
+-commutative58.8%
fma-define60.9%
*-commutative60.9%
*-commutative60.9%
cancel-sign-sub-inv60.9%
cancel-sign-sub60.9%
fma-neg62.9%
distribute-rgt-neg-out62.9%
remove-double-neg62.9%
*-commutative62.9%
*-commutative62.9%
Simplified62.9%
Taylor expanded in i around inf 79.9%
distribute-lft-out--79.9%
*-commutative79.9%
Simplified79.9%
Taylor expanded in y around 0 43.5%
Final simplification41.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= i -7.4e+48) (not (<= i 1.9e+47))) (* i (- (* a b) (* y j))) (* t (- (* c j) (* x a)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -7.4e+48) || !(i <= 1.9e+47)) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t * ((c * j) - (x * a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((i <= (-7.4d+48)) .or. (.not. (i <= 1.9d+47))) then
tmp = i * ((a * b) - (y * j))
else
tmp = t * ((c * j) - (x * a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -7.4e+48) || !(i <= 1.9e+47)) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t * ((c * j) - (x * a));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (i <= -7.4e+48) or not (i <= 1.9e+47): tmp = i * ((a * b) - (y * j)) else: tmp = t * ((c * j) - (x * a)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((i <= -7.4e+48) || !(i <= 1.9e+47)) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((i <= -7.4e+48) || ~((i <= 1.9e+47))) tmp = i * ((a * b) - (y * j)); else tmp = t * ((c * j) - (x * a)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[i, -7.4e+48], N[Not[LessEqual[i, 1.9e+47]], $MachinePrecision]], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -7.4 \cdot 10^{+48} \lor \neg \left(i \leq 1.9 \cdot 10^{+47}\right):\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\end{array}
\end{array}
if i < -7.3999999999999998e48 or 1.9000000000000002e47 < i Initial program 63.4%
+-commutative63.4%
fma-define64.3%
*-commutative64.3%
*-commutative64.3%
cancel-sign-sub-inv64.3%
cancel-sign-sub64.3%
fma-neg66.1%
distribute-rgt-neg-out66.1%
remove-double-neg66.1%
*-commutative66.1%
*-commutative66.1%
Simplified66.1%
Taylor expanded in i around inf 69.2%
distribute-lft-out--69.2%
*-commutative69.2%
Simplified69.2%
Taylor expanded in i around 0 69.2%
mul-1-neg69.2%
*-commutative69.2%
distribute-rgt-neg-out69.2%
neg-mul-169.2%
*-commutative69.2%
distribute-lft-out--69.2%
sub-neg69.2%
neg-mul-169.2%
remove-double-neg69.2%
+-commutative69.2%
mul-1-neg69.2%
*-commutative69.2%
unsub-neg69.2%
Simplified69.2%
if -7.3999999999999998e48 < i < 1.9000000000000002e47Initial program 80.2%
+-commutative80.2%
fma-define82.9%
*-commutative82.9%
*-commutative82.9%
cancel-sign-sub-inv82.9%
cancel-sign-sub82.9%
fma-neg82.9%
distribute-rgt-neg-out82.9%
remove-double-neg82.9%
*-commutative82.9%
*-commutative82.9%
Simplified82.9%
Taylor expanded in t around inf 59.4%
+-commutative59.4%
mul-1-neg59.4%
unsub-neg59.4%
*-commutative59.4%
Simplified59.4%
Final simplification63.6%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= c -3.8e-11) (not (<= c 1.45e-57))) (* c (- (* t j) (* z b))) (* i (- (* a b) (* y j)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -3.8e-11) || !(c <= 1.45e-57)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((c <= (-3.8d-11)) .or. (.not. (c <= 1.45d-57))) then
tmp = c * ((t * j) - (z * b))
else
tmp = i * ((a * b) - (y * j))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -3.8e-11) || !(c <= 1.45e-57)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (c <= -3.8e-11) or not (c <= 1.45e-57): tmp = c * ((t * j) - (z * b)) else: tmp = i * ((a * b) - (y * j)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((c <= -3.8e-11) || !(c <= 1.45e-57)) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((c <= -3.8e-11) || ~((c <= 1.45e-57))) tmp = c * ((t * j) - (z * b)); else tmp = i * ((a * b) - (y * j)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[c, -3.8e-11], N[Not[LessEqual[c, 1.45e-57]], $MachinePrecision]], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.8 \cdot 10^{-11} \lor \neg \left(c \leq 1.45 \cdot 10^{-57}\right):\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if c < -3.7999999999999998e-11 or 1.45000000000000013e-57 < c Initial program 67.2%
+-commutative67.2%
fma-define68.7%
*-commutative68.7%
*-commutative68.7%
cancel-sign-sub-inv68.7%
cancel-sign-sub68.7%
fma-neg70.3%
distribute-rgt-neg-out70.3%
remove-double-neg70.3%
*-commutative70.3%
*-commutative70.3%
Simplified70.3%
Taylor expanded in c around inf 57.5%
*-commutative57.5%
*-commutative57.5%
Simplified57.5%
if -3.7999999999999998e-11 < c < 1.45000000000000013e-57Initial program 78.8%
+-commutative78.8%
fma-define81.1%
*-commutative81.1%
*-commutative81.1%
cancel-sign-sub-inv81.1%
cancel-sign-sub81.1%
fma-neg81.1%
distribute-rgt-neg-out81.1%
remove-double-neg81.1%
*-commutative81.1%
*-commutative81.1%
Simplified81.1%
Taylor expanded in i around inf 57.1%
distribute-lft-out--57.1%
*-commutative57.1%
Simplified57.1%
Taylor expanded in i around 0 57.1%
mul-1-neg57.1%
*-commutative57.1%
distribute-rgt-neg-out57.1%
neg-mul-157.1%
*-commutative57.1%
distribute-lft-out--57.1%
sub-neg57.1%
neg-mul-157.1%
remove-double-neg57.1%
+-commutative57.1%
mul-1-neg57.1%
*-commutative57.1%
unsub-neg57.1%
Simplified57.1%
Final simplification57.3%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= i -3.05e+47) (not (<= i 1.25e+126))) (* a (* b i)) (* c (* t j))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -3.05e+47) || !(i <= 1.25e+126)) {
tmp = a * (b * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((i <= (-3.05d+47)) .or. (.not. (i <= 1.25d+126))) then
tmp = a * (b * i)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -3.05e+47) || !(i <= 1.25e+126)) {
tmp = a * (b * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (i <= -3.05e+47) or not (i <= 1.25e+126): tmp = a * (b * i) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((i <= -3.05e+47) || !(i <= 1.25e+126)) tmp = Float64(a * Float64(b * i)); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((i <= -3.05e+47) || ~((i <= 1.25e+126))) tmp = a * (b * i); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[i, -3.05e+47], N[Not[LessEqual[i, 1.25e+126]], $MachinePrecision]], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -3.05 \cdot 10^{+47} \lor \neg \left(i \leq 1.25 \cdot 10^{+126}\right):\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if i < -3.05000000000000009e47 or 1.24999999999999994e126 < i Initial program 60.8%
+-commutative60.8%
fma-define61.9%
*-commutative61.9%
*-commutative61.9%
cancel-sign-sub-inv61.9%
cancel-sign-sub61.9%
fma-neg63.9%
distribute-rgt-neg-out63.9%
remove-double-neg63.9%
*-commutative63.9%
*-commutative63.9%
Simplified63.9%
Taylor expanded in i around inf 72.5%
distribute-lft-out--72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in y around 0 46.5%
if -3.05000000000000009e47 < i < 1.24999999999999994e126Initial program 80.1%
+-commutative80.1%
fma-define82.6%
*-commutative82.6%
*-commutative82.6%
cancel-sign-sub-inv82.6%
cancel-sign-sub82.6%
fma-neg82.6%
distribute-rgt-neg-out82.6%
remove-double-neg82.6%
*-commutative82.6%
*-commutative82.6%
Simplified82.6%
Taylor expanded in c around inf 45.5%
*-commutative45.5%
*-commutative45.5%
Simplified45.5%
Taylor expanded in t around inf 31.0%
*-commutative31.0%
Simplified31.0%
Final simplification36.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -1.05e+49) (* a (* b i)) (if (<= i 1.3e+126) (* c (* t j)) (* i (* a b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.05e+49) {
tmp = a * (b * i);
} else if (i <= 1.3e+126) {
tmp = c * (t * j);
} else {
tmp = i * (a * b);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (i <= (-1.05d+49)) then
tmp = a * (b * i)
else if (i <= 1.3d+126) then
tmp = c * (t * j)
else
tmp = i * (a * b)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.05e+49) {
tmp = a * (b * i);
} else if (i <= 1.3e+126) {
tmp = c * (t * j);
} else {
tmp = i * (a * b);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.05e+49: tmp = a * (b * i) elif i <= 1.3e+126: tmp = c * (t * j) else: tmp = i * (a * b) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.05e+49) tmp = Float64(a * Float64(b * i)); elseif (i <= 1.3e+126) tmp = Float64(c * Float64(t * j)); else tmp = Float64(i * Float64(a * b)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.05e+49) tmp = a * (b * i); elseif (i <= 1.3e+126) tmp = c * (t * j); else tmp = i * (a * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.05e+49], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.3e+126], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.05 \cdot 10^{+49}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq 1.3 \cdot 10^{+126}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if i < -1.05000000000000005e49Initial program 65.7%
+-commutative65.7%
fma-define65.7%
*-commutative65.7%
*-commutative65.7%
cancel-sign-sub-inv65.7%
cancel-sign-sub65.7%
fma-neg67.5%
distribute-rgt-neg-out67.5%
remove-double-neg67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
Taylor expanded in i around inf 64.4%
distribute-lft-out--64.4%
*-commutative64.4%
Simplified64.4%
Taylor expanded in y around 0 47.5%
if -1.05000000000000005e49 < i < 1.3e126Initial program 80.1%
+-commutative80.1%
fma-define82.6%
*-commutative82.6%
*-commutative82.6%
cancel-sign-sub-inv82.6%
cancel-sign-sub82.6%
fma-neg82.6%
distribute-rgt-neg-out82.6%
remove-double-neg82.6%
*-commutative82.6%
*-commutative82.6%
Simplified82.6%
Taylor expanded in c around inf 45.5%
*-commutative45.5%
*-commutative45.5%
Simplified45.5%
Taylor expanded in t around inf 31.0%
*-commutative31.0%
Simplified31.0%
if 1.3e126 < i Initial program 54.2%
+-commutative54.2%
fma-define56.7%
*-commutative56.7%
*-commutative56.7%
cancel-sign-sub-inv56.7%
cancel-sign-sub56.7%
fma-neg59.1%
distribute-rgt-neg-out59.1%
remove-double-neg59.1%
*-commutative59.1%
*-commutative59.1%
Simplified59.1%
Taylor expanded in i around inf 83.3%
distribute-lft-out--83.3%
*-commutative83.3%
Simplified83.3%
Taylor expanded in y around 0 48.0%
(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.9%
+-commutative72.9%
fma-define74.8%
*-commutative74.8%
*-commutative74.8%
cancel-sign-sub-inv74.8%
cancel-sign-sub74.8%
fma-neg75.6%
distribute-rgt-neg-out75.6%
remove-double-neg75.6%
*-commutative75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in i around inf 41.1%
distribute-lft-out--41.1%
*-commutative41.1%
Simplified41.1%
Taylor expanded in y around 0 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 2024146
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1015122364899489/125000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -942510763643697/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (if (< t -238547917063487/3125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 10535888557455487/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* 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)))))