
(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 27 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 (* (* y 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 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = (y * i) * ((a * (b / y)) - j);
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = (y * i) * ((a * (b / y)) - j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = (y * i) * ((a * (b / y)) - j) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = (y * 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[(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[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $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}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 94.5%
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%
+-commutative0.0%
fma-define8.2%
*-commutative8.2%
*-commutative8.2%
cancel-sign-sub-inv8.2%
cancel-sign-sub8.2%
fmm-def16.3%
distribute-rgt-neg-out16.3%
remove-double-neg16.3%
*-commutative16.3%
*-commutative16.3%
Simplified16.3%
Taylor expanded in y around -inf 38.8%
Simplified38.8%
Taylor expanded in i around inf 49.4%
Taylor expanded in i around inf 49.8%
associate-*r*53.6%
associate-/l*53.6%
Simplified53.6%
Final simplification86.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.25e+110)
(* (* y i) (- (* a (/ b y)) j))
(if (<= i -5.2e-144)
(+ (* x (* y z)) (* j (* t c)))
(if (<= i 1.45e-78)
(* c (- (* t j) (* z b)))
(if (<= i 3.8e+197)
(* y (+ (* x z) (- (/ (* a (* b i)) y) (* i j))))
(* i (* a (- b (* j (/ y 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 <= -1.25e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -5.2e-144) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.45e-78) {
tmp = c * ((t * j) - (z * b));
} else if (i <= 3.8e+197) {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
} else {
tmp = i * (a * (b - (j * (y / 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 <= (-1.25d+110)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= (-5.2d-144)) then
tmp = (x * (y * z)) + (j * (t * c))
else if (i <= 1.45d-78) then
tmp = c * ((t * j) - (z * b))
else if (i <= 3.8d+197) then
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)))
else
tmp = i * (a * (b - (j * (y / 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 <= -1.25e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -5.2e-144) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.45e-78) {
tmp = c * ((t * j) - (z * b));
} else if (i <= 3.8e+197) {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
} else {
tmp = i * (a * (b - (j * (y / a))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.25e+110: tmp = (y * i) * ((a * (b / y)) - j) elif i <= -5.2e-144: tmp = (x * (y * z)) + (j * (t * c)) elif i <= 1.45e-78: tmp = c * ((t * j) - (z * b)) elif i <= 3.8e+197: tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))) else: tmp = i * (a * (b - (j * (y / a)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.25e+110) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= -5.2e-144) tmp = Float64(Float64(x * Float64(y * z)) + Float64(j * Float64(t * c))); elseif (i <= 1.45e-78) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (i <= 3.8e+197) tmp = Float64(y * Float64(Float64(x * z) + Float64(Float64(Float64(a * Float64(b * i)) / y) - Float64(i * j)))); else tmp = Float64(i * Float64(a * Float64(b - Float64(j * Float64(y / a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.25e+110) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= -5.2e-144) tmp = (x * (y * z)) + (j * (t * c)); elseif (i <= 1.45e-78) tmp = c * ((t * j) - (z * b)); elseif (i <= 3.8e+197) tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))); else tmp = i * (a * (b - (j * (y / a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.25e+110], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -5.2e-144], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.45e-78], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.8e+197], N[(y * N[(N[(x * z), $MachinePrecision] + N[(N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * N[(b - N[(j * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.25 \cdot 10^{+110}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq -5.2 \cdot 10^{-144}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 1.45 \cdot 10^{-78}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;i \leq 3.8 \cdot 10^{+197}:\\
\;\;\;\;y \cdot \left(x \cdot z + \left(\frac{a \cdot \left(b \cdot i\right)}{y} - i \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot \left(b - j \cdot \frac{y}{a}\right)\right)\\
\end{array}
\end{array}
if i < -1.24999999999999995e110Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -1.24999999999999995e110 < i < -5.2000000000000002e-144Initial program 87.7%
cancel-sign-sub-inv87.7%
cancel-sign-sub87.7%
*-commutative87.7%
fmm-def87.7%
distribute-rgt-neg-in87.7%
remove-double-neg87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
Simplified87.7%
Taylor expanded in z around inf 75.9%
Taylor expanded in x around inf 70.8%
Taylor expanded in t around inf 75.7%
if -5.2000000000000002e-144 < i < 1.45e-78Initial program 85.7%
+-commutative85.7%
fma-define87.9%
*-commutative87.9%
*-commutative87.9%
cancel-sign-sub-inv87.9%
cancel-sign-sub87.9%
fmm-def90.0%
distribute-rgt-neg-out90.0%
remove-double-neg90.0%
*-commutative90.0%
*-commutative90.0%
Simplified90.0%
Taylor expanded in c around inf 62.1%
*-commutative62.1%
*-commutative62.1%
Simplified62.1%
if 1.45e-78 < i < 3.8000000000000001e197Initial program 76.3%
+-commutative76.3%
fma-define77.8%
*-commutative77.8%
*-commutative77.8%
cancel-sign-sub-inv77.8%
cancel-sign-sub77.8%
fmm-def79.3%
distribute-rgt-neg-out79.3%
remove-double-neg79.3%
*-commutative79.3%
*-commutative79.3%
Simplified79.3%
Taylor expanded in y around -inf 75.0%
Simplified73.3%
Taylor expanded in i around inf 73.8%
if 3.8000000000000001e197 < i Initial program 59.1%
+-commutative59.1%
fma-define59.1%
*-commutative59.1%
*-commutative59.1%
cancel-sign-sub-inv59.1%
cancel-sign-sub59.1%
fmm-def65.0%
distribute-rgt-neg-out65.0%
remove-double-neg65.0%
*-commutative65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in i around inf 83.1%
distribute-lft-out--83.1%
*-commutative83.1%
Simplified83.1%
Taylor expanded in a around -inf 83.1%
associate-*r*83.1%
neg-mul-183.1%
neg-mul-183.1%
+-commutative83.1%
sub-neg83.1%
associate-/l*83.2%
Simplified83.2%
Final simplification71.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (- (* x y) (* b c)))))
(if (<= z -2.1e+23)
t_1
(if (<= z -1.82e-40)
(* y (- (* x z) (* i j)))
(if (<= z -3.15e-114)
(* t (- (* c j) (* x a)))
(if (<= z -3.7e-168)
(* i (* a b))
(if (<= z 8.5e+23) (* j (- (* t c) (* y i))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * ((x * y) - (b * c));
double tmp;
if (z <= -2.1e+23) {
tmp = t_1;
} else if (z <= -1.82e-40) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -3.15e-114) {
tmp = t * ((c * j) - (x * a));
} else if (z <= -3.7e-168) {
tmp = i * (a * b);
} else if (z <= 8.5e+23) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = z * ((x * y) - (b * c))
if (z <= (-2.1d+23)) then
tmp = t_1
else if (z <= (-1.82d-40)) then
tmp = y * ((x * z) - (i * j))
else if (z <= (-3.15d-114)) then
tmp = t * ((c * j) - (x * a))
else if (z <= (-3.7d-168)) then
tmp = i * (a * b)
else if (z <= 8.5d+23) then
tmp = j * ((t * c) - (y * i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * ((x * y) - (b * c));
double tmp;
if (z <= -2.1e+23) {
tmp = t_1;
} else if (z <= -1.82e-40) {
tmp = y * ((x * z) - (i * j));
} else if (z <= -3.15e-114) {
tmp = t * ((c * j) - (x * a));
} else if (z <= -3.7e-168) {
tmp = i * (a * b);
} else if (z <= 8.5e+23) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * ((x * y) - (b * c)) tmp = 0 if z <= -2.1e+23: tmp = t_1 elif z <= -1.82e-40: tmp = y * ((x * z) - (i * j)) elif z <= -3.15e-114: tmp = t * ((c * j) - (x * a)) elif z <= -3.7e-168: tmp = i * (a * b) elif z <= 8.5e+23: tmp = j * ((t * c) - (y * i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(Float64(x * y) - Float64(b * c))) tmp = 0.0 if (z <= -2.1e+23) tmp = t_1; elseif (z <= -1.82e-40) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); elseif (z <= -3.15e-114) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (z <= -3.7e-168) tmp = Float64(i * Float64(a * b)); elseif (z <= 8.5e+23) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * ((x * y) - (b * c)); tmp = 0.0; if (z <= -2.1e+23) tmp = t_1; elseif (z <= -1.82e-40) tmp = y * ((x * z) - (i * j)); elseif (z <= -3.15e-114) tmp = t * ((c * j) - (x * a)); elseif (z <= -3.7e-168) tmp = i * (a * b); elseif (z <= 8.5e+23) tmp = j * ((t * c) - (y * i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.1e+23], t$95$1, If[LessEqual[z, -1.82e-40], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.15e-114], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.7e-168], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.5e+23], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;z \leq -2.1 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.82 \cdot 10^{-40}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{elif}\;z \leq -3.15 \cdot 10^{-114}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;z \leq -3.7 \cdot 10^{-168}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq 8.5 \cdot 10^{+23}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.1000000000000001e23 or 8.5000000000000001e23 < z Initial program 68.6%
cancel-sign-sub-inv68.6%
cancel-sign-sub68.6%
*-commutative68.6%
fmm-def72.2%
distribute-rgt-neg-in72.2%
remove-double-neg72.2%
*-commutative72.2%
*-commutative72.2%
*-commutative72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in z around inf 71.1%
Taylor expanded in z around inf 65.3%
if -2.1000000000000001e23 < z < -1.82000000000000006e-40Initial program 87.2%
+-commutative87.2%
fma-define87.2%
*-commutative87.2%
*-commutative87.2%
cancel-sign-sub-inv87.2%
cancel-sign-sub87.2%
fmm-def87.2%
distribute-rgt-neg-out87.2%
remove-double-neg87.2%
*-commutative87.2%
*-commutative87.2%
Simplified87.2%
Taylor expanded in y around inf 61.3%
+-commutative61.3%
mul-1-neg61.3%
unsub-neg61.3%
Simplified61.3%
if -1.82000000000000006e-40 < z < -3.15000000000000007e-114Initial program 89.5%
+-commutative89.5%
fma-define89.5%
*-commutative89.5%
*-commutative89.5%
cancel-sign-sub-inv89.5%
cancel-sign-sub89.5%
fmm-def89.5%
distribute-rgt-neg-out89.5%
remove-double-neg89.5%
*-commutative89.5%
*-commutative89.5%
Simplified89.5%
Taylor expanded in t around inf 80.7%
+-commutative80.7%
mul-1-neg80.7%
unsub-neg80.7%
*-commutative80.7%
Simplified80.7%
if -3.15000000000000007e-114 < z < -3.69999999999999997e-168Initial program 69.2%
+-commutative69.2%
fma-define69.2%
*-commutative69.2%
*-commutative69.2%
cancel-sign-sub-inv69.2%
cancel-sign-sub69.2%
fmm-def69.2%
distribute-rgt-neg-out69.2%
remove-double-neg69.2%
*-commutative69.2%
*-commutative69.2%
Simplified69.2%
Taylor expanded in i around inf 75.6%
distribute-lft-out--75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in y around 0 75.3%
if -3.69999999999999997e-168 < z < 8.5000000000000001e23Initial program 82.4%
+-commutative82.4%
fma-define85.6%
*-commutative85.6%
*-commutative85.6%
cancel-sign-sub-inv85.6%
cancel-sign-sub85.6%
fmm-def85.6%
distribute-rgt-neg-out85.6%
remove-double-neg85.6%
*-commutative85.6%
*-commutative85.6%
Simplified85.6%
Taylor expanded in j around inf 62.5%
*-commutative62.5%
*-commutative62.5%
Simplified62.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (- (* x z) (* i j)))))
(if (<= z -1.3e-40)
t_1
(if (<= z -1.9e-114)
(* t (- (* c j) (* x a)))
(if (<= z -6.8e-167)
(* i (* a b))
(if (<= z 7e-69)
(* j (- (* t c) (* y i)))
(if (<= z 4e+68) (* 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 = y * ((x * z) - (i * j));
double tmp;
if (z <= -1.3e-40) {
tmp = t_1;
} else if (z <= -1.9e-114) {
tmp = t * ((c * j) - (x * a));
} else if (z <= -6.8e-167) {
tmp = i * (a * b);
} else if (z <= 7e-69) {
tmp = j * ((t * c) - (y * i));
} else if (z <= 4e+68) {
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 = y * ((x * z) - (i * j))
if (z <= (-1.3d-40)) then
tmp = t_1
else if (z <= (-1.9d-114)) then
tmp = t * ((c * j) - (x * a))
else if (z <= (-6.8d-167)) then
tmp = i * (a * b)
else if (z <= 7d-69) then
tmp = j * ((t * c) - (y * i))
else if (z <= 4d+68) 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 = y * ((x * z) - (i * j));
double tmp;
if (z <= -1.3e-40) {
tmp = t_1;
} else if (z <= -1.9e-114) {
tmp = t * ((c * j) - (x * a));
} else if (z <= -6.8e-167) {
tmp = i * (a * b);
} else if (z <= 7e-69) {
tmp = j * ((t * c) - (y * i));
} else if (z <= 4e+68) {
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 = y * ((x * z) - (i * j)) tmp = 0 if z <= -1.3e-40: tmp = t_1 elif z <= -1.9e-114: tmp = t * ((c * j) - (x * a)) elif z <= -6.8e-167: tmp = i * (a * b) elif z <= 7e-69: tmp = j * ((t * c) - (y * i)) elif z <= 4e+68: 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(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (z <= -1.3e-40) tmp = t_1; elseif (z <= -1.9e-114) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (z <= -6.8e-167) tmp = Float64(i * Float64(a * b)); elseif (z <= 7e-69) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (z <= 4e+68) 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 = y * ((x * z) - (i * j)); tmp = 0.0; if (z <= -1.3e-40) tmp = t_1; elseif (z <= -1.9e-114) tmp = t * ((c * j) - (x * a)); elseif (z <= -6.8e-167) tmp = i * (a * b); elseif (z <= 7e-69) tmp = j * ((t * c) - (y * i)); elseif (z <= 4e+68) 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[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.3e-40], t$95$1, If[LessEqual[z, -1.9e-114], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -6.8e-167], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7e-69], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e+68], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;z \leq -1.3 \cdot 10^{-40}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.9 \cdot 10^{-114}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;z \leq -6.8 \cdot 10^{-167}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq 7 \cdot 10^{-69}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;z \leq 4 \cdot 10^{+68}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.3000000000000001e-40 or 3.99999999999999981e68 < z Initial program 70.8%
+-commutative70.8%
fma-define71.6%
*-commutative71.6%
*-commutative71.6%
cancel-sign-sub-inv71.6%
cancel-sign-sub71.6%
fmm-def74.8%
distribute-rgt-neg-out74.8%
remove-double-neg74.8%
*-commutative74.8%
*-commutative74.8%
Simplified74.8%
Taylor expanded in y around inf 55.3%
+-commutative55.3%
mul-1-neg55.3%
unsub-neg55.3%
Simplified55.3%
if -1.3000000000000001e-40 < z < -1.8999999999999999e-114Initial program 89.5%
+-commutative89.5%
fma-define89.5%
*-commutative89.5%
*-commutative89.5%
cancel-sign-sub-inv89.5%
cancel-sign-sub89.5%
fmm-def89.5%
distribute-rgt-neg-out89.5%
remove-double-neg89.5%
*-commutative89.5%
*-commutative89.5%
Simplified89.5%
Taylor expanded in t around inf 80.7%
+-commutative80.7%
mul-1-neg80.7%
unsub-neg80.7%
*-commutative80.7%
Simplified80.7%
if -1.8999999999999999e-114 < z < -6.7999999999999995e-167Initial program 69.2%
+-commutative69.2%
fma-define69.2%
*-commutative69.2%
*-commutative69.2%
cancel-sign-sub-inv69.2%
cancel-sign-sub69.2%
fmm-def69.2%
distribute-rgt-neg-out69.2%
remove-double-neg69.2%
*-commutative69.2%
*-commutative69.2%
Simplified69.2%
Taylor expanded in i around inf 75.6%
distribute-lft-out--75.6%
*-commutative75.6%
Simplified75.6%
Taylor expanded in y around 0 75.3%
if -6.7999999999999995e-167 < z < 7.0000000000000003e-69Initial program 87.2%
+-commutative87.2%
fma-define88.6%
*-commutative88.6%
*-commutative88.6%
cancel-sign-sub-inv88.6%
cancel-sign-sub88.6%
fmm-def88.6%
distribute-rgt-neg-out88.6%
remove-double-neg88.6%
*-commutative88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in j around inf 67.5%
*-commutative67.5%
*-commutative67.5%
Simplified67.5%
if 7.0000000000000003e-69 < z < 3.99999999999999981e68Initial program 70.8%
+-commutative70.8%
fma-define78.2%
*-commutative78.2%
*-commutative78.2%
cancel-sign-sub-inv78.2%
cancel-sign-sub78.2%
fmm-def78.2%
distribute-rgt-neg-out78.2%
remove-double-neg78.2%
*-commutative78.2%
*-commutative78.2%
Simplified78.2%
Taylor expanded in c around inf 56.8%
*-commutative56.8%
*-commutative56.8%
Simplified56.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.2e+113)
(* (* y i) (- (* a (/ b y)) j))
(if (<= i 1.5e-20)
(+ (* x (- (* y z) (* t a))) (* j (- (* t c) (* y i))))
(if (<= i 1.9e+195)
(* y (+ (* x z) (- (/ (* a (* b i)) y) (* i j))))
(* i (* a (- b (* j (/ y 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 <= -1.2e+113) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 1.5e-20) {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
} else if (i <= 1.9e+195) {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
} else {
tmp = i * (a * (b - (j * (y / 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 <= (-1.2d+113)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= 1.5d-20) then
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)))
else if (i <= 1.9d+195) then
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)))
else
tmp = i * (a * (b - (j * (y / 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 <= -1.2e+113) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 1.5e-20) {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
} else if (i <= 1.9e+195) {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
} else {
tmp = i * (a * (b - (j * (y / a))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.2e+113: tmp = (y * i) * ((a * (b / y)) - j) elif i <= 1.5e-20: tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))) elif i <= 1.9e+195: tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))) else: tmp = i * (a * (b - (j * (y / a)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.2e+113) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= 1.5e-20) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); elseif (i <= 1.9e+195) tmp = Float64(y * Float64(Float64(x * z) + Float64(Float64(Float64(a * Float64(b * i)) / y) - Float64(i * j)))); else tmp = Float64(i * Float64(a * Float64(b - Float64(j * Float64(y / a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.2e+113) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= 1.5e-20) tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))); elseif (i <= 1.9e+195) tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))); else tmp = i * (a * (b - (j * (y / a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.2e+113], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.5e-20], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.9e+195], N[(y * N[(N[(x * z), $MachinePrecision] + N[(N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * N[(b - N[(j * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.2 \cdot 10^{+113}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq 1.5 \cdot 10^{-20}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;i \leq 1.9 \cdot 10^{+195}:\\
\;\;\;\;y \cdot \left(x \cdot z + \left(\frac{a \cdot \left(b \cdot i\right)}{y} - i \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot \left(b - j \cdot \frac{y}{a}\right)\right)\\
\end{array}
\end{array}
if i < -1.19999999999999992e113Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -1.19999999999999992e113 < i < 1.50000000000000014e-20Initial program 86.9%
Taylor expanded in b around 0 69.8%
if 1.50000000000000014e-20 < i < 1.9e195Initial program 73.9%
+-commutative73.9%
fma-define75.6%
*-commutative75.6%
*-commutative75.6%
cancel-sign-sub-inv75.6%
cancel-sign-sub75.6%
fmm-def77.2%
distribute-rgt-neg-out77.2%
remove-double-neg77.2%
*-commutative77.2%
*-commutative77.2%
Simplified77.2%
Taylor expanded in y around -inf 72.6%
Simplified70.7%
Taylor expanded in i around inf 75.9%
if 1.9e195 < i Initial program 59.1%
+-commutative59.1%
fma-define59.1%
*-commutative59.1%
*-commutative59.1%
cancel-sign-sub-inv59.1%
cancel-sign-sub59.1%
fmm-def65.0%
distribute-rgt-neg-out65.0%
remove-double-neg65.0%
*-commutative65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in i around inf 83.1%
distribute-lft-out--83.1%
*-commutative83.1%
Simplified83.1%
Taylor expanded in a around -inf 83.1%
associate-*r*83.1%
neg-mul-183.1%
neg-mul-183.1%
+-commutative83.1%
sub-neg83.1%
associate-/l*83.2%
Simplified83.2%
Final simplification73.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= z -3.1e-38)
t_1
(if (<= z -2.7e-110)
(* x (* t (- a)))
(if (<= z -5.8e-186)
(* i (* a b))
(if (<= z 2.15e-39)
(* j (* t c))
(if (<= z 1.08e+71) (* b (* c (- z))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (z <= -3.1e-38) {
tmp = t_1;
} else if (z <= -2.7e-110) {
tmp = x * (t * -a);
} else if (z <= -5.8e-186) {
tmp = i * (a * b);
} else if (z <= 2.15e-39) {
tmp = j * (t * c);
} else if (z <= 1.08e+71) {
tmp = b * (c * -z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (z <= (-3.1d-38)) then
tmp = t_1
else if (z <= (-2.7d-110)) then
tmp = x * (t * -a)
else if (z <= (-5.8d-186)) then
tmp = i * (a * b)
else if (z <= 2.15d-39) then
tmp = j * (t * c)
else if (z <= 1.08d+71) then
tmp = b * (c * -z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (z <= -3.1e-38) {
tmp = t_1;
} else if (z <= -2.7e-110) {
tmp = x * (t * -a);
} else if (z <= -5.8e-186) {
tmp = i * (a * b);
} else if (z <= 2.15e-39) {
tmp = j * (t * c);
} else if (z <= 1.08e+71) {
tmp = b * (c * -z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if z <= -3.1e-38: tmp = t_1 elif z <= -2.7e-110: tmp = x * (t * -a) elif z <= -5.8e-186: tmp = i * (a * b) elif z <= 2.15e-39: tmp = j * (t * c) elif z <= 1.08e+71: tmp = b * (c * -z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (z <= -3.1e-38) tmp = t_1; elseif (z <= -2.7e-110) tmp = Float64(x * Float64(t * Float64(-a))); elseif (z <= -5.8e-186) tmp = Float64(i * Float64(a * b)); elseif (z <= 2.15e-39) tmp = Float64(j * Float64(t * c)); elseif (z <= 1.08e+71) tmp = Float64(b * Float64(c * Float64(-z))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (z <= -3.1e-38) tmp = t_1; elseif (z <= -2.7e-110) tmp = x * (t * -a); elseif (z <= -5.8e-186) tmp = i * (a * b); elseif (z <= 2.15e-39) tmp = j * (t * c); elseif (z <= 1.08e+71) tmp = b * (c * -z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.1e-38], t$95$1, If[LessEqual[z, -2.7e-110], N[(x * N[(t * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.8e-186], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.15e-39], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.08e+71], N[(b * N[(c * (-z)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;z \leq -3.1 \cdot 10^{-38}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -2.7 \cdot 10^{-110}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-a\right)\right)\\
\mathbf{elif}\;z \leq -5.8 \cdot 10^{-186}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq 2.15 \cdot 10^{-39}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;z \leq 1.08 \cdot 10^{+71}:\\
\;\;\;\;b \cdot \left(c \cdot \left(-z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.09999999999999983e-38 or 1.08e71 < z Initial program 71.1%
+-commutative71.1%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
fmm-def74.3%
distribute-rgt-neg-out74.3%
remove-double-neg74.3%
*-commutative74.3%
*-commutative74.3%
Simplified74.3%
Taylor expanded in y around -inf 69.0%
Simplified69.7%
Taylor expanded in x around inf 53.4%
associate-*r*49.1%
associate-*r/49.1%
associate-*r*49.1%
neg-mul-149.1%
Simplified49.1%
Taylor expanded in y around inf 43.3%
if -3.09999999999999983e-38 < z < -2.6999999999999998e-110Initial program 90.1%
+-commutative90.1%
fma-define90.1%
*-commutative90.1%
*-commutative90.1%
cancel-sign-sub-inv90.1%
cancel-sign-sub90.1%
fmm-def90.1%
distribute-rgt-neg-out90.1%
remove-double-neg90.1%
*-commutative90.1%
*-commutative90.1%
Simplified90.1%
Taylor expanded in y around -inf 93.8%
Simplified93.8%
Taylor expanded in x around inf 60.4%
associate-*r*51.5%
associate-*r/51.5%
associate-*r*51.5%
neg-mul-151.5%
Simplified51.5%
Taylor expanded in y around 0 46.0%
mul-1-neg46.0%
associate-*r*52.0%
*-commutative52.0%
Simplified52.0%
if -2.6999999999999998e-110 < z < -5.80000000000000038e-186Initial program 72.5%
+-commutative72.5%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
fmm-def72.5%
distribute-rgt-neg-out72.5%
remove-double-neg72.5%
*-commutative72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in i around inf 73.0%
distribute-lft-out--73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in y around 0 72.7%
if -5.80000000000000038e-186 < z < 2.15e-39Initial program 87.4%
+-commutative87.4%
fma-define88.7%
*-commutative88.7%
*-commutative88.7%
cancel-sign-sub-inv88.7%
cancel-sign-sub88.7%
fmm-def88.7%
distribute-rgt-neg-out88.7%
remove-double-neg88.7%
*-commutative88.7%
*-commutative88.7%
Simplified88.7%
Taylor expanded in j around inf 66.6%
*-commutative66.6%
*-commutative66.6%
Simplified66.6%
Taylor expanded in t around inf 44.2%
if 2.15e-39 < z < 1.08e71Initial program 64.6%
+-commutative64.6%
fma-define72.6%
*-commutative72.6%
*-commutative72.6%
cancel-sign-sub-inv72.6%
cancel-sign-sub72.6%
fmm-def76.6%
distribute-rgt-neg-out76.6%
remove-double-neg76.6%
*-commutative76.6%
*-commutative76.6%
Simplified76.6%
Taylor expanded in c around inf 49.6%
*-commutative49.6%
*-commutative49.6%
Simplified49.6%
Taylor expanded in t around 0 41.8%
associate-*r*41.8%
neg-mul-141.8%
Simplified41.8%
Final simplification46.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= z -2.7e-39)
t_1
(if (<= z -4e-108)
(* x (* t (- a)))
(if (<= z -3.6e-186)
(* i (* a b))
(if (<= z 1.2e-42)
(* j (* t c))
(if (<= z 1.06e+71) (- (* c (* 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 = x * (y * z);
double tmp;
if (z <= -2.7e-39) {
tmp = t_1;
} else if (z <= -4e-108) {
tmp = x * (t * -a);
} else if (z <= -3.6e-186) {
tmp = i * (a * b);
} else if (z <= 1.2e-42) {
tmp = j * (t * c);
} else if (z <= 1.06e+71) {
tmp = -(c * (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 = x * (y * z)
if (z <= (-2.7d-39)) then
tmp = t_1
else if (z <= (-4d-108)) then
tmp = x * (t * -a)
else if (z <= (-3.6d-186)) then
tmp = i * (a * b)
else if (z <= 1.2d-42) then
tmp = j * (t * c)
else if (z <= 1.06d+71) then
tmp = -(c * (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 = x * (y * z);
double tmp;
if (z <= -2.7e-39) {
tmp = t_1;
} else if (z <= -4e-108) {
tmp = x * (t * -a);
} else if (z <= -3.6e-186) {
tmp = i * (a * b);
} else if (z <= 1.2e-42) {
tmp = j * (t * c);
} else if (z <= 1.06e+71) {
tmp = -(c * (z * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if z <= -2.7e-39: tmp = t_1 elif z <= -4e-108: tmp = x * (t * -a) elif z <= -3.6e-186: tmp = i * (a * b) elif z <= 1.2e-42: tmp = j * (t * c) elif z <= 1.06e+71: tmp = -(c * (z * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (z <= -2.7e-39) tmp = t_1; elseif (z <= -4e-108) tmp = Float64(x * Float64(t * Float64(-a))); elseif (z <= -3.6e-186) tmp = Float64(i * Float64(a * b)); elseif (z <= 1.2e-42) tmp = Float64(j * Float64(t * c)); elseif (z <= 1.06e+71) tmp = Float64(-Float64(c * 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 = x * (y * z); tmp = 0.0; if (z <= -2.7e-39) tmp = t_1; elseif (z <= -4e-108) tmp = x * (t * -a); elseif (z <= -3.6e-186) tmp = i * (a * b); elseif (z <= 1.2e-42) tmp = j * (t * c); elseif (z <= 1.06e+71) tmp = -(c * (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[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -2.7e-39], t$95$1, If[LessEqual[z, -4e-108], N[(x * N[(t * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3.6e-186], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.2e-42], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.06e+71], (-N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;z \leq -2.7 \cdot 10^{-39}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -4 \cdot 10^{-108}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-a\right)\right)\\
\mathbf{elif}\;z \leq -3.6 \cdot 10^{-186}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{-42}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;z \leq 1.06 \cdot 10^{+71}:\\
\;\;\;\;-c \cdot \left(z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -2.7000000000000001e-39 or 1.06e71 < z Initial program 71.1%
+-commutative71.1%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
fmm-def74.3%
distribute-rgt-neg-out74.3%
remove-double-neg74.3%
*-commutative74.3%
*-commutative74.3%
Simplified74.3%
Taylor expanded in y around -inf 69.0%
Simplified69.7%
Taylor expanded in x around inf 53.4%
associate-*r*49.1%
associate-*r/49.1%
associate-*r*49.1%
neg-mul-149.1%
Simplified49.1%
Taylor expanded in y around inf 43.3%
if -2.7000000000000001e-39 < z < -4.00000000000000016e-108Initial program 90.1%
+-commutative90.1%
fma-define90.1%
*-commutative90.1%
*-commutative90.1%
cancel-sign-sub-inv90.1%
cancel-sign-sub90.1%
fmm-def90.1%
distribute-rgt-neg-out90.1%
remove-double-neg90.1%
*-commutative90.1%
*-commutative90.1%
Simplified90.1%
Taylor expanded in y around -inf 93.8%
Simplified93.8%
Taylor expanded in x around inf 60.4%
associate-*r*51.5%
associate-*r/51.5%
associate-*r*51.5%
neg-mul-151.5%
Simplified51.5%
Taylor expanded in y around 0 46.0%
mul-1-neg46.0%
associate-*r*52.0%
*-commutative52.0%
Simplified52.0%
if -4.00000000000000016e-108 < z < -3.5999999999999998e-186Initial program 72.5%
+-commutative72.5%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
fmm-def72.5%
distribute-rgt-neg-out72.5%
remove-double-neg72.5%
*-commutative72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in i around inf 73.0%
distribute-lft-out--73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in y around 0 72.7%
if -3.5999999999999998e-186 < z < 1.20000000000000001e-42Initial program 87.4%
+-commutative87.4%
fma-define88.7%
*-commutative88.7%
*-commutative88.7%
cancel-sign-sub-inv88.7%
cancel-sign-sub88.7%
fmm-def88.7%
distribute-rgt-neg-out88.7%
remove-double-neg88.7%
*-commutative88.7%
*-commutative88.7%
Simplified88.7%
Taylor expanded in j around inf 66.6%
*-commutative66.6%
*-commutative66.6%
Simplified66.6%
Taylor expanded in t around inf 44.2%
if 1.20000000000000001e-42 < z < 1.06e71Initial program 64.6%
+-commutative64.6%
fma-define72.6%
*-commutative72.6%
*-commutative72.6%
cancel-sign-sub-inv72.6%
cancel-sign-sub72.6%
fmm-def76.6%
distribute-rgt-neg-out76.6%
remove-double-neg76.6%
*-commutative76.6%
*-commutative76.6%
Simplified76.6%
Taylor expanded in c around inf 49.6%
*-commutative49.6%
*-commutative49.6%
Simplified49.6%
Taylor expanded in t around 0 38.3%
neg-mul-138.3%
distribute-rgt-neg-in38.3%
Simplified38.3%
Final simplification45.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= z -1.06e+39)
(* z (- (* x y) (* b c)))
(if (<= z 1e-172)
(+ t_1 (* a (* b i)))
(if (<= z 4.9e+89)
(- t_1 (* b (* z c)))
(* (* y z) (- x (* b (/ c y)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (z <= -1.06e+39) {
tmp = z * ((x * y) - (b * c));
} else if (z <= 1e-172) {
tmp = t_1 + (a * (b * i));
} else if (z <= 4.9e+89) {
tmp = t_1 - (b * (z * c));
} else {
tmp = (y * z) * (x - (b * (c / y)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = j * ((t * c) - (y * i))
if (z <= (-1.06d+39)) then
tmp = z * ((x * y) - (b * c))
else if (z <= 1d-172) then
tmp = t_1 + (a * (b * i))
else if (z <= 4.9d+89) then
tmp = t_1 - (b * (z * c))
else
tmp = (y * z) * (x - (b * (c / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (z <= -1.06e+39) {
tmp = z * ((x * y) - (b * c));
} else if (z <= 1e-172) {
tmp = t_1 + (a * (b * i));
} else if (z <= 4.9e+89) {
tmp = t_1 - (b * (z * c));
} else {
tmp = (y * z) * (x - (b * (c / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) tmp = 0 if z <= -1.06e+39: tmp = z * ((x * y) - (b * c)) elif z <= 1e-172: tmp = t_1 + (a * (b * i)) elif z <= 4.9e+89: tmp = t_1 - (b * (z * c)) else: tmp = (y * z) * (x - (b * (c / y))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (z <= -1.06e+39) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (z <= 1e-172) tmp = Float64(t_1 + Float64(a * Float64(b * i))); elseif (z <= 4.9e+89) tmp = Float64(t_1 - Float64(b * Float64(z * c))); else tmp = Float64(Float64(y * z) * Float64(x - Float64(b * Float64(c / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((t * c) - (y * i)); tmp = 0.0; if (z <= -1.06e+39) tmp = z * ((x * y) - (b * c)); elseif (z <= 1e-172) tmp = t_1 + (a * (b * i)); elseif (z <= 4.9e+89) tmp = t_1 - (b * (z * c)); else tmp = (y * z) * (x - (b * (c / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.06e+39], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1e-172], N[(t$95$1 + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.9e+89], N[(t$95$1 - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * z), $MachinePrecision] * N[(x - N[(b * N[(c / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;z \leq -1.06 \cdot 10^{+39}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;z \leq 10^{-172}:\\
\;\;\;\;t\_1 + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+89}:\\
\;\;\;\;t\_1 - b \cdot \left(z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot z\right) \cdot \left(x - b \cdot \frac{c}{y}\right)\\
\end{array}
\end{array}
if z < -1.06000000000000005e39Initial program 66.8%
cancel-sign-sub-inv66.8%
cancel-sign-sub66.8%
*-commutative66.8%
fmm-def68.8%
distribute-rgt-neg-in68.8%
remove-double-neg68.8%
*-commutative68.8%
*-commutative68.8%
*-commutative68.8%
*-commutative68.8%
Simplified68.8%
Taylor expanded in z around inf 78.7%
Taylor expanded in z around inf 70.6%
if -1.06000000000000005e39 < z < 1e-172Initial program 84.9%
cancel-sign-sub-inv84.9%
cancel-sign-sub84.9%
*-commutative84.9%
fmm-def85.8%
distribute-rgt-neg-in85.8%
remove-double-neg85.8%
*-commutative85.8%
*-commutative85.8%
*-commutative85.8%
*-commutative85.8%
Simplified85.8%
Taylor expanded in i around inf 67.2%
if 1e-172 < z < 4.89999999999999996e89Initial program 76.1%
cancel-sign-sub-inv76.1%
cancel-sign-sub76.1%
*-commutative76.1%
fmm-def78.1%
distribute-rgt-neg-in78.1%
remove-double-neg78.1%
*-commutative78.1%
*-commutative78.1%
*-commutative78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in c around inf 70.5%
associate-*r*70.5%
neg-mul-170.5%
*-commutative70.5%
Simplified70.5%
if 4.89999999999999996e89 < z Initial program 66.8%
+-commutative66.8%
fma-define66.8%
*-commutative66.8%
*-commutative66.8%
cancel-sign-sub-inv66.8%
cancel-sign-sub66.8%
fmm-def69.0%
distribute-rgt-neg-out69.0%
remove-double-neg69.0%
*-commutative69.0%
*-commutative69.0%
Simplified69.0%
Taylor expanded in y around -inf 68.9%
Simplified73.4%
Taylor expanded in z around inf 76.2%
associate-*r*70.0%
*-commutative70.0%
associate-/l*69.9%
Simplified69.9%
Final simplification69.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (or (<= b -2.7e-18) (not (<= b 2.3e+60)))
(+ t_1 (* b (- (* a i) (* z c))))
(+ t_1 (* j (- (* t c) (* y i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if ((b <= -2.7e-18) || !(b <= 2.3e+60)) {
tmp = t_1 + (b * ((a * i) - (z * c)));
} else {
tmp = t_1 + (j * ((t * c) - (y * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if ((b <= (-2.7d-18)) .or. (.not. (b <= 2.3d+60))) then
tmp = t_1 + (b * ((a * i) - (z * c)))
else
tmp = t_1 + (j * ((t * c) - (y * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if ((b <= -2.7e-18) || !(b <= 2.3e+60)) {
tmp = t_1 + (b * ((a * i) - (z * c)));
} else {
tmp = t_1 + (j * ((t * c) - (y * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if (b <= -2.7e-18) or not (b <= 2.3e+60): tmp = t_1 + (b * ((a * i) - (z * c))) else: tmp = t_1 + (j * ((t * c) - (y * i))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if ((b <= -2.7e-18) || !(b <= 2.3e+60)) tmp = Float64(t_1 + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); else tmp = Float64(t_1 + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if ((b <= -2.7e-18) || ~((b <= 2.3e+60))) tmp = t_1 + (b * ((a * i) - (z * c))); else tmp = t_1 + (j * ((t * c) - (y * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[b, -2.7e-18], N[Not[LessEqual[b, 2.3e+60]], $MachinePrecision]], N[(t$95$1 + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;b \leq -2.7 \cdot 10^{-18} \lor \neg \left(b \leq 2.3 \cdot 10^{+60}\right):\\
\;\;\;\;t\_1 + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 + j \cdot \left(t \cdot c - y \cdot i\right)\\
\end{array}
\end{array}
if b < -2.69999999999999989e-18 or 2.30000000000000017e60 < b Initial program 76.1%
Taylor expanded in j around 0 71.2%
if -2.69999999999999989e-18 < b < 2.30000000000000017e60Initial program 76.6%
Taylor expanded in b around 0 77.3%
Final simplification74.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))) (t_2 (* b (- (* a i) (* z c)))))
(if (<= b -2.9e-9)
(+ (* y (- (* x z) (* i j))) t_2)
(if (<= b 2.5e+64) (+ t_1 (* j (- (* t c) (* y i)))) (+ t_1 t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -2.9e-9) {
tmp = (y * ((x * z) - (i * j))) + t_2;
} else if (b <= 2.5e+64) {
tmp = t_1 + (j * ((t * c) - (y * i)));
} else {
tmp = t_1 + t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
t_2 = b * ((a * i) - (z * c))
if (b <= (-2.9d-9)) then
tmp = (y * ((x * z) - (i * j))) + t_2
else if (b <= 2.5d+64) then
tmp = t_1 + (j * ((t * c) - (y * i)))
else
tmp = t_1 + t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double t_2 = b * ((a * i) - (z * c));
double tmp;
if (b <= -2.9e-9) {
tmp = (y * ((x * z) - (i * j))) + t_2;
} else if (b <= 2.5e+64) {
tmp = t_1 + (j * ((t * c) - (y * i)));
} else {
tmp = t_1 + t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) t_2 = b * ((a * i) - (z * c)) tmp = 0 if b <= -2.9e-9: tmp = (y * ((x * z) - (i * j))) + t_2 elif b <= 2.5e+64: tmp = t_1 + (j * ((t * c) - (y * i))) else: tmp = t_1 + t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) t_2 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -2.9e-9) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + t_2); elseif (b <= 2.5e+64) tmp = Float64(t_1 + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); else tmp = Float64(t_1 + t_2); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); t_2 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -2.9e-9) tmp = (y * ((x * z) - (i * j))) + t_2; elseif (b <= 2.5e+64) tmp = t_1 + (j * ((t * c) - (y * i))); else tmp = t_1 + t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.9e-9], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[b, 2.5e+64], N[(t$95$1 + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + t$95$2), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_2 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -2.9 \cdot 10^{-9}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + t\_2\\
\mathbf{elif}\;b \leq 2.5 \cdot 10^{+64}:\\
\;\;\;\;t\_1 + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 + t\_2\\
\end{array}
\end{array}
if b < -2.89999999999999991e-9Initial program 76.9%
+-commutative76.9%
fma-define80.5%
*-commutative80.5%
*-commutative80.5%
cancel-sign-sub-inv80.5%
cancel-sign-sub80.5%
fmm-def82.3%
distribute-rgt-neg-out82.3%
remove-double-neg82.3%
*-commutative82.3%
*-commutative82.3%
Simplified82.3%
Taylor expanded in t around 0 68.9%
associate-*r*70.5%
associate-*r*70.5%
*-commutative70.5%
associate-*r*73.7%
distribute-rgt-in75.5%
+-commutative75.5%
mul-1-neg75.5%
unsub-neg75.5%
*-commutative75.5%
Simplified75.5%
if -2.89999999999999991e-9 < b < 2.5e64Initial program 76.3%
Taylor expanded in b around 0 77.0%
if 2.5e64 < b Initial program 76.3%
Taylor expanded in j around 0 72.6%
Final simplification75.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -5.4e+113)
(* (* y i) (- (* a (/ b y)) j))
(if (<= i 8e+53)
(+ (* z (- (* x y) (* b c))) (* j (- (* t c) (* y i))))
(* i (* a (- b (* j (/ y 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 <= -5.4e+113) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 8e+53) {
tmp = (z * ((x * y) - (b * c))) + (j * ((t * c) - (y * i)));
} else {
tmp = i * (a * (b - (j * (y / 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 <= (-5.4d+113)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= 8d+53) then
tmp = (z * ((x * y) - (b * c))) + (j * ((t * c) - (y * i)))
else
tmp = i * (a * (b - (j * (y / 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 <= -5.4e+113) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 8e+53) {
tmp = (z * ((x * y) - (b * c))) + (j * ((t * c) - (y * i)));
} else {
tmp = i * (a * (b - (j * (y / a))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -5.4e+113: tmp = (y * i) * ((a * (b / y)) - j) elif i <= 8e+53: tmp = (z * ((x * y) - (b * c))) + (j * ((t * c) - (y * i))) else: tmp = i * (a * (b - (j * (y / a)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -5.4e+113) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= 8e+53) tmp = Float64(Float64(z * Float64(Float64(x * y) - Float64(b * c))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); else tmp = Float64(i * Float64(a * Float64(b - Float64(j * Float64(y / a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -5.4e+113) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= 8e+53) tmp = (z * ((x * y) - (b * c))) + (j * ((t * c) - (y * i))); else tmp = i * (a * (b - (j * (y / a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -5.4e+113], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 8e+53], N[(N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * N[(b - N[(j * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -5.4 \cdot 10^{+113}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq 8 \cdot 10^{+53}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot \left(b - j \cdot \frac{y}{a}\right)\right)\\
\end{array}
\end{array}
if i < -5.40000000000000022e113Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -5.40000000000000022e113 < i < 7.9999999999999999e53Initial program 85.0%
cancel-sign-sub-inv85.0%
cancel-sign-sub85.0%
*-commutative85.0%
fmm-def86.8%
distribute-rgt-neg-in86.8%
remove-double-neg86.8%
*-commutative86.8%
*-commutative86.8%
*-commutative86.8%
*-commutative86.8%
Simplified86.8%
Taylor expanded in z around inf 72.6%
if 7.9999999999999999e53 < i Initial program 69.9%
+-commutative69.9%
fma-define69.9%
*-commutative69.9%
*-commutative69.9%
cancel-sign-sub-inv69.9%
cancel-sign-sub69.9%
fmm-def71.7%
distribute-rgt-neg-out71.7%
remove-double-neg71.7%
*-commutative71.7%
*-commutative71.7%
Simplified71.7%
Taylor expanded in i around inf 72.2%
distribute-lft-out--72.2%
*-commutative72.2%
Simplified72.2%
Taylor expanded in a around -inf 73.9%
associate-*r*73.9%
neg-mul-173.9%
neg-mul-173.9%
+-commutative73.9%
sub-neg73.9%
associate-/l*74.1%
Simplified74.1%
Final simplification73.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.05e+110)
(* (* y i) (- (* a (/ b y)) j))
(if (<= i -5.5e-138)
(+ (* x (* y z)) (* j (* t c)))
(if (<= i 1.12e-10)
(* c (- (* t j) (* z b)))
(* i (* a (- b (* j (/ y 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 <= -1.05e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -5.5e-138) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.12e-10) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * (a * (b - (j * (y / 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 <= (-1.05d+110)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= (-5.5d-138)) then
tmp = (x * (y * z)) + (j * (t * c))
else if (i <= 1.12d-10) then
tmp = c * ((t * j) - (z * b))
else
tmp = i * (a * (b - (j * (y / 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 <= -1.05e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -5.5e-138) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.12e-10) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * (a * (b - (j * (y / a))));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -1.05e+110: tmp = (y * i) * ((a * (b / y)) - j) elif i <= -5.5e-138: tmp = (x * (y * z)) + (j * (t * c)) elif i <= 1.12e-10: tmp = c * ((t * j) - (z * b)) else: tmp = i * (a * (b - (j * (y / a)))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.05e+110) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= -5.5e-138) tmp = Float64(Float64(x * Float64(y * z)) + Float64(j * Float64(t * c))); elseif (i <= 1.12e-10) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(i * Float64(a * Float64(b - Float64(j * Float64(y / a))))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (i <= -1.05e+110) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= -5.5e-138) tmp = (x * (y * z)) + (j * (t * c)); elseif (i <= 1.12e-10) tmp = c * ((t * j) - (z * b)); else tmp = i * (a * (b - (j * (y / a)))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.05e+110], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -5.5e-138], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.12e-10], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * N[(b - N[(j * N[(y / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.05 \cdot 10^{+110}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq -5.5 \cdot 10^{-138}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 1.12 \cdot 10^{-10}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot \left(b - j \cdot \frac{y}{a}\right)\right)\\
\end{array}
\end{array}
if i < -1.05000000000000007e110Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -1.05000000000000007e110 < i < -5.5000000000000003e-138Initial program 87.7%
cancel-sign-sub-inv87.7%
cancel-sign-sub87.7%
*-commutative87.7%
fmm-def87.7%
distribute-rgt-neg-in87.7%
remove-double-neg87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
Simplified87.7%
Taylor expanded in z around inf 75.9%
Taylor expanded in x around inf 70.8%
Taylor expanded in t around inf 75.7%
if -5.5000000000000003e-138 < i < 1.12e-10Initial program 85.1%
+-commutative85.1%
fma-define88.1%
*-commutative88.1%
*-commutative88.1%
cancel-sign-sub-inv88.1%
cancel-sign-sub88.1%
fmm-def90.0%
distribute-rgt-neg-out90.0%
remove-double-neg90.0%
*-commutative90.0%
*-commutative90.0%
Simplified90.0%
Taylor expanded in c around inf 60.1%
*-commutative60.1%
*-commutative60.1%
Simplified60.1%
if 1.12e-10 < i Initial program 71.8%
+-commutative71.8%
fma-define71.8%
*-commutative71.8%
*-commutative71.8%
cancel-sign-sub-inv71.8%
cancel-sign-sub71.8%
fmm-def74.5%
distribute-rgt-neg-out74.5%
remove-double-neg74.5%
*-commutative74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in i around inf 68.5%
distribute-lft-out--68.5%
*-commutative68.5%
Simplified68.5%
Taylor expanded in a around -inf 68.5%
associate-*r*68.5%
neg-mul-168.5%
neg-mul-168.5%
+-commutative68.5%
sub-neg68.5%
associate-/l*68.7%
Simplified68.7%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= z -1.12e-39)
t_1
(if (<= z -1.75e-102)
(* x (* t (- a)))
(if (<= z -5.1e-186)
(* i (* a b))
(if (<= z 5.2e+89) (* j (* t 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 = x * (y * z);
double tmp;
if (z <= -1.12e-39) {
tmp = t_1;
} else if (z <= -1.75e-102) {
tmp = x * (t * -a);
} else if (z <= -5.1e-186) {
tmp = i * (a * b);
} else if (z <= 5.2e+89) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (z <= (-1.12d-39)) then
tmp = t_1
else if (z <= (-1.75d-102)) then
tmp = x * (t * -a)
else if (z <= (-5.1d-186)) then
tmp = i * (a * b)
else if (z <= 5.2d+89) then
tmp = j * (t * 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 = x * (y * z);
double tmp;
if (z <= -1.12e-39) {
tmp = t_1;
} else if (z <= -1.75e-102) {
tmp = x * (t * -a);
} else if (z <= -5.1e-186) {
tmp = i * (a * b);
} else if (z <= 5.2e+89) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if z <= -1.12e-39: tmp = t_1 elif z <= -1.75e-102: tmp = x * (t * -a) elif z <= -5.1e-186: tmp = i * (a * b) elif z <= 5.2e+89: tmp = j * (t * c) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (z <= -1.12e-39) tmp = t_1; elseif (z <= -1.75e-102) tmp = Float64(x * Float64(t * Float64(-a))); elseif (z <= -5.1e-186) tmp = Float64(i * Float64(a * b)); elseif (z <= 5.2e+89) tmp = Float64(j * Float64(t * c)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (z <= -1.12e-39) tmp = t_1; elseif (z <= -1.75e-102) tmp = x * (t * -a); elseif (z <= -5.1e-186) tmp = i * (a * b); elseif (z <= 5.2e+89) tmp = j * (t * 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[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.12e-39], t$95$1, If[LessEqual[z, -1.75e-102], N[(x * N[(t * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -5.1e-186], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.2e+89], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;z \leq -1.12 \cdot 10^{-39}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -1.75 \cdot 10^{-102}:\\
\;\;\;\;x \cdot \left(t \cdot \left(-a\right)\right)\\
\mathbf{elif}\;z \leq -5.1 \cdot 10^{-186}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;z \leq 5.2 \cdot 10^{+89}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.12e-39 or 5.2000000000000001e89 < z Initial program 70.4%
+-commutative70.4%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
fmm-def73.7%
distribute-rgt-neg-out73.7%
remove-double-neg73.7%
*-commutative73.7%
*-commutative73.7%
Simplified73.7%
Taylor expanded in y around -inf 69.8%
Simplified70.5%
Taylor expanded in x around inf 54.6%
associate-*r*50.3%
associate-*r/50.3%
associate-*r*50.3%
neg-mul-150.3%
Simplified50.3%
Taylor expanded in y around inf 44.3%
if -1.12e-39 < z < -1.74999999999999993e-102Initial program 90.1%
+-commutative90.1%
fma-define90.1%
*-commutative90.1%
*-commutative90.1%
cancel-sign-sub-inv90.1%
cancel-sign-sub90.1%
fmm-def90.1%
distribute-rgt-neg-out90.1%
remove-double-neg90.1%
*-commutative90.1%
*-commutative90.1%
Simplified90.1%
Taylor expanded in y around -inf 93.8%
Simplified93.8%
Taylor expanded in x around inf 60.4%
associate-*r*51.5%
associate-*r/51.5%
associate-*r*51.5%
neg-mul-151.5%
Simplified51.5%
Taylor expanded in y around 0 46.0%
mul-1-neg46.0%
associate-*r*52.0%
*-commutative52.0%
Simplified52.0%
if -1.74999999999999993e-102 < z < -5.1000000000000003e-186Initial program 72.5%
+-commutative72.5%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
fmm-def72.5%
distribute-rgt-neg-out72.5%
remove-double-neg72.5%
*-commutative72.5%
*-commutative72.5%
Simplified72.5%
Taylor expanded in i around inf 73.0%
distribute-lft-out--73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in y around 0 72.7%
if -5.1000000000000003e-186 < z < 5.2000000000000001e89Initial program 82.1%
+-commutative82.1%
fma-define85.1%
*-commutative85.1%
*-commutative85.1%
cancel-sign-sub-inv85.1%
cancel-sign-sub85.1%
fmm-def86.1%
distribute-rgt-neg-out86.1%
remove-double-neg86.1%
*-commutative86.1%
*-commutative86.1%
Simplified86.1%
Taylor expanded in j around inf 56.5%
*-commutative56.5%
*-commutative56.5%
Simplified56.5%
Taylor expanded in t around inf 35.5%
Final simplification43.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= z -1.06e+39)
(* z (- (* x y) (* b c)))
(if (<= z 5.5e+23)
(+ (* j (- (* t c) (* y i))) (* a (* b i)))
(* (* y z) (- x (* b (/ c y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.06e+39) {
tmp = z * ((x * y) - (b * c));
} else if (z <= 5.5e+23) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else {
tmp = (y * z) * (x - (b * (c / y)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (z <= (-1.06d+39)) then
tmp = z * ((x * y) - (b * c))
else if (z <= 5.5d+23) then
tmp = (j * ((t * c) - (y * i))) + (a * (b * i))
else
tmp = (y * z) * (x - (b * (c / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (z <= -1.06e+39) {
tmp = z * ((x * y) - (b * c));
} else if (z <= 5.5e+23) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else {
tmp = (y * z) * (x - (b * (c / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if z <= -1.06e+39: tmp = z * ((x * y) - (b * c)) elif z <= 5.5e+23: tmp = (j * ((t * c) - (y * i))) + (a * (b * i)) else: tmp = (y * z) * (x - (b * (c / y))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (z <= -1.06e+39) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (z <= 5.5e+23) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(a * Float64(b * i))); else tmp = Float64(Float64(y * z) * Float64(x - Float64(b * Float64(c / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (z <= -1.06e+39) tmp = z * ((x * y) - (b * c)); elseif (z <= 5.5e+23) tmp = (j * ((t * c) - (y * i))) + (a * (b * i)); else tmp = (y * z) * (x - (b * (c / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[z, -1.06e+39], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.5e+23], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * z), $MachinePrecision] * N[(x - N[(b * N[(c / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.06 \cdot 10^{+39}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;z \leq 5.5 \cdot 10^{+23}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot z\right) \cdot \left(x - b \cdot \frac{c}{y}\right)\\
\end{array}
\end{array}
if z < -1.06000000000000005e39Initial program 66.8%
cancel-sign-sub-inv66.8%
cancel-sign-sub66.8%
*-commutative66.8%
fmm-def68.8%
distribute-rgt-neg-in68.8%
remove-double-neg68.8%
*-commutative68.8%
*-commutative68.8%
*-commutative68.8%
*-commutative68.8%
Simplified68.8%
Taylor expanded in z around inf 78.7%
Taylor expanded in z around inf 70.6%
if -1.06000000000000005e39 < z < 5.50000000000000004e23Initial program 82.1%
cancel-sign-sub-inv82.1%
cancel-sign-sub82.1%
*-commutative82.1%
fmm-def82.8%
distribute-rgt-neg-in82.8%
remove-double-neg82.8%
*-commutative82.8%
*-commutative82.8%
*-commutative82.8%
*-commutative82.8%
Simplified82.8%
Taylor expanded in i around inf 65.7%
if 5.50000000000000004e23 < z Initial program 70.2%
+-commutative70.2%
fma-define70.2%
*-commutative70.2%
*-commutative70.2%
cancel-sign-sub-inv70.2%
cancel-sign-sub70.2%
fmm-def73.7%
distribute-rgt-neg-out73.7%
remove-double-neg73.7%
*-commutative73.7%
*-commutative73.7%
Simplified73.7%
Taylor expanded in y around -inf 68.7%
Simplified70.4%
Taylor expanded in z around inf 67.7%
associate-*r*67.3%
*-commutative67.3%
associate-/l*67.1%
Simplified67.1%
Final simplification67.0%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -9e+110)
(* (* y i) (- (* a (/ b y)) j))
(if (<= i -1.7e-141)
(+ (* x (* y z)) (* j (* t c)))
(if (<= i 1.25e-11)
(* 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 (i <= -9e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -1.7e-141) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.25e-11) {
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 (i <= (-9d+110)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= (-1.7d-141)) then
tmp = (x * (y * z)) + (j * (t * c))
else if (i <= 1.25d-11) 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 (i <= -9e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= -1.7e-141) {
tmp = (x * (y * z)) + (j * (t * c));
} else if (i <= 1.25e-11) {
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 i <= -9e+110: tmp = (y * i) * ((a * (b / y)) - j) elif i <= -1.7e-141: tmp = (x * (y * z)) + (j * (t * c)) elif i <= 1.25e-11: 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 (i <= -9e+110) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= -1.7e-141) tmp = Float64(Float64(x * Float64(y * z)) + Float64(j * Float64(t * c))); elseif (i <= 1.25e-11) 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 (i <= -9e+110) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= -1.7e-141) tmp = (x * (y * z)) + (j * (t * c)); elseif (i <= 1.25e-11) 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[LessEqual[i, -9e+110], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.7e-141], N[(N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision] + N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.25e-11], 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}\;i \leq -9 \cdot 10^{+110}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq -1.7 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right) + j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;i \leq 1.25 \cdot 10^{-11}:\\
\;\;\;\;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 i < -9.0000000000000005e110Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -9.0000000000000005e110 < i < -1.6999999999999999e-141Initial program 87.7%
cancel-sign-sub-inv87.7%
cancel-sign-sub87.7%
*-commutative87.7%
fmm-def87.7%
distribute-rgt-neg-in87.7%
remove-double-neg87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
*-commutative87.7%
Simplified87.7%
Taylor expanded in z around inf 75.9%
Taylor expanded in x around inf 70.8%
Taylor expanded in t around inf 75.7%
if -1.6999999999999999e-141 < i < 1.25000000000000005e-11Initial program 85.1%
+-commutative85.1%
fma-define88.1%
*-commutative88.1%
*-commutative88.1%
cancel-sign-sub-inv88.1%
cancel-sign-sub88.1%
fmm-def90.0%
distribute-rgt-neg-out90.0%
remove-double-neg90.0%
*-commutative90.0%
*-commutative90.0%
Simplified90.0%
Taylor expanded in c around inf 60.1%
*-commutative60.1%
*-commutative60.1%
Simplified60.1%
if 1.25000000000000005e-11 < i Initial program 71.8%
+-commutative71.8%
fma-define71.8%
*-commutative71.8%
*-commutative71.8%
cancel-sign-sub-inv71.8%
cancel-sign-sub71.8%
fmm-def74.5%
distribute-rgt-neg-out74.5%
remove-double-neg74.5%
*-commutative74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in i around inf 68.5%
distribute-lft-out--68.5%
*-commutative68.5%
Simplified68.5%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= b -2.75e-39)
t_1
(if (<= b 5.4e-189)
(* t (- (* c j) (* x a)))
(if (<= b 6.5e+85) (* j (- (* t c) (* y i))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (b <= -2.75e-39) {
tmp = t_1;
} else if (b <= 5.4e-189) {
tmp = t * ((c * j) - (x * a));
} else if (b <= 6.5e+85) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * ((t * j) - (z * b))
if (b <= (-2.75d-39)) then
tmp = t_1
else if (b <= 5.4d-189) then
tmp = t * ((c * j) - (x * a))
else if (b <= 6.5d+85) then
tmp = j * ((t * c) - (y * i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (b <= -2.75e-39) {
tmp = t_1;
} else if (b <= 5.4e-189) {
tmp = t * ((c * j) - (x * a));
} else if (b <= 6.5e+85) {
tmp = j * ((t * c) - (y * i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((t * j) - (z * b)) tmp = 0 if b <= -2.75e-39: tmp = t_1 elif b <= 5.4e-189: tmp = t * ((c * j) - (x * a)) elif b <= 6.5e+85: tmp = j * ((t * c) - (y * i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (b <= -2.75e-39) tmp = t_1; elseif (b <= 5.4e-189) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (b <= 6.5e+85) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((t * j) - (z * b)); tmp = 0.0; if (b <= -2.75e-39) tmp = t_1; elseif (b <= 5.4e-189) tmp = t * ((c * j) - (x * a)); elseif (b <= 6.5e+85) tmp = j * ((t * c) - (y * i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.75e-39], t$95$1, If[LessEqual[b, 5.4e-189], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 6.5e+85], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;b \leq -2.75 \cdot 10^{-39}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 5.4 \cdot 10^{-189}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;b \leq 6.5 \cdot 10^{+85}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -2.75000000000000009e-39 or 6.4999999999999994e85 < b Initial program 76.9%
+-commutative76.9%
fma-define80.3%
*-commutative80.3%
*-commutative80.3%
cancel-sign-sub-inv80.3%
cancel-sign-sub80.3%
fmm-def82.1%
distribute-rgt-neg-out82.1%
remove-double-neg82.1%
*-commutative82.1%
*-commutative82.1%
Simplified82.1%
Taylor expanded in c around inf 56.1%
*-commutative56.1%
*-commutative56.1%
Simplified56.1%
if -2.75000000000000009e-39 < b < 5.3999999999999999e-189Initial program 77.4%
+-commutative77.4%
fma-define77.4%
*-commutative77.4%
*-commutative77.4%
cancel-sign-sub-inv77.4%
cancel-sign-sub77.4%
fmm-def78.7%
distribute-rgt-neg-out78.7%
remove-double-neg78.7%
*-commutative78.7%
*-commutative78.7%
Simplified78.7%
Taylor expanded in t around inf 61.1%
+-commutative61.1%
mul-1-neg61.1%
unsub-neg61.1%
*-commutative61.1%
Simplified61.1%
if 5.3999999999999999e-189 < b < 6.4999999999999994e85Initial program 74.1%
+-commutative74.1%
fma-define74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
fmm-def75.7%
distribute-rgt-neg-out75.7%
remove-double-neg75.7%
*-commutative75.7%
*-commutative75.7%
Simplified75.7%
Taylor expanded in j around inf 56.4%
*-commutative56.4%
*-commutative56.4%
Simplified56.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -2.6e-72)
t_1
(if (<= c 2.5e-182) (* z (* x y)) (if (<= c 8e-33) (* a (* b i)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (c <= -2.6e-72) {
tmp = t_1;
} else if (c <= 2.5e-182) {
tmp = z * (x * y);
} else if (c <= 8e-33) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * ((t * j) - (z * b))
if (c <= (-2.6d-72)) then
tmp = t_1
else if (c <= 2.5d-182) then
tmp = z * (x * y)
else if (c <= 8d-33) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (c <= -2.6e-72) {
tmp = t_1;
} else if (c <= 2.5e-182) {
tmp = z * (x * y);
} else if (c <= 8e-33) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((t * j) - (z * b)) tmp = 0 if c <= -2.6e-72: tmp = t_1 elif c <= 2.5e-182: tmp = z * (x * y) elif c <= 8e-33: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -2.6e-72) tmp = t_1; elseif (c <= 2.5e-182) tmp = Float64(z * Float64(x * y)); elseif (c <= 8e-33) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -2.6e-72) tmp = t_1; elseif (c <= 2.5e-182) tmp = z * (x * y); elseif (c <= 8e-33) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2.6e-72], t$95$1, If[LessEqual[c, 2.5e-182], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 8e-33], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -2.6 \cdot 10^{-72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 2.5 \cdot 10^{-182}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;c \leq 8 \cdot 10^{-33}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -2.59999999999999996e-72 or 8.0000000000000004e-33 < c Initial program 71.7%
+-commutative71.7%
fma-define74.4%
*-commutative74.4%
*-commutative74.4%
cancel-sign-sub-inv74.4%
cancel-sign-sub74.4%
fmm-def76.5%
distribute-rgt-neg-out76.5%
remove-double-neg76.5%
*-commutative76.5%
*-commutative76.5%
Simplified76.5%
Taylor expanded in c around inf 60.8%
*-commutative60.8%
*-commutative60.8%
Simplified60.8%
if -2.59999999999999996e-72 < c < 2.50000000000000012e-182Initial program 84.6%
cancel-sign-sub-inv84.6%
cancel-sign-sub84.6%
*-commutative84.6%
fmm-def85.9%
distribute-rgt-neg-in85.9%
remove-double-neg85.9%
*-commutative85.9%
*-commutative85.9%
*-commutative85.9%
*-commutative85.9%
Simplified85.9%
Taylor expanded in z around inf 60.8%
Taylor expanded in z around inf 43.5%
Taylor expanded in x around inf 38.3%
associate-*r*39.4%
Simplified39.4%
if 2.50000000000000012e-182 < c < 8.0000000000000004e-33Initial program 77.8%
+-commutative77.8%
fma-define77.8%
*-commutative77.8%
*-commutative77.8%
cancel-sign-sub-inv77.8%
cancel-sign-sub77.8%
fmm-def77.8%
distribute-rgt-neg-out77.8%
remove-double-neg77.8%
*-commutative77.8%
*-commutative77.8%
Simplified77.8%
Taylor expanded in i around inf 55.8%
distribute-lft-out--55.8%
*-commutative55.8%
Simplified55.8%
Taylor expanded in y around 0 44.1%
Final simplification52.1%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -3.4e-72)
(* j (* t c))
(if (<= c 3.4e-179)
(* z (* x y))
(if (<= c 4.9e+57) (* a (* b i)) (* t (* c 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.4e-72) {
tmp = j * (t * c);
} else if (c <= 3.4e-179) {
tmp = z * (x * y);
} else if (c <= 4.9e+57) {
tmp = a * (b * i);
} else {
tmp = t * (c * 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.4d-72)) then
tmp = j * (t * c)
else if (c <= 3.4d-179) then
tmp = z * (x * y)
else if (c <= 4.9d+57) then
tmp = a * (b * i)
else
tmp = t * (c * 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.4e-72) {
tmp = j * (t * c);
} else if (c <= 3.4e-179) {
tmp = z * (x * y);
} else if (c <= 4.9e+57) {
tmp = a * (b * i);
} else {
tmp = t * (c * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if c <= -3.4e-72: tmp = j * (t * c) elif c <= 3.4e-179: tmp = z * (x * y) elif c <= 4.9e+57: tmp = a * (b * i) else: tmp = t * (c * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -3.4e-72) tmp = Float64(j * Float64(t * c)); elseif (c <= 3.4e-179) tmp = Float64(z * Float64(x * y)); elseif (c <= 4.9e+57) tmp = Float64(a * Float64(b * i)); else tmp = Float64(t * Float64(c * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (c <= -3.4e-72) tmp = j * (t * c); elseif (c <= 3.4e-179) tmp = z * (x * y); elseif (c <= 4.9e+57) tmp = a * (b * i); else tmp = t * (c * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -3.4e-72], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.4e-179], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4.9e+57], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.4 \cdot 10^{-72}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq 3.4 \cdot 10^{-179}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\mathbf{elif}\;c \leq 4.9 \cdot 10^{+57}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\end{array}
\end{array}
if c < -3.3999999999999998e-72Initial program 69.6%
+-commutative69.6%
fma-define73.4%
*-commutative73.4%
*-commutative73.4%
cancel-sign-sub-inv73.4%
cancel-sign-sub73.4%
fmm-def75.9%
distribute-rgt-neg-out75.9%
remove-double-neg75.9%
*-commutative75.9%
*-commutative75.9%
Simplified75.9%
Taylor expanded in j around inf 57.8%
*-commutative57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in t around inf 42.0%
if -3.3999999999999998e-72 < c < 3.3999999999999997e-179Initial program 84.6%
cancel-sign-sub-inv84.6%
cancel-sign-sub84.6%
*-commutative84.6%
fmm-def85.9%
distribute-rgt-neg-in85.9%
remove-double-neg85.9%
*-commutative85.9%
*-commutative85.9%
*-commutative85.9%
*-commutative85.9%
Simplified85.9%
Taylor expanded in z around inf 60.8%
Taylor expanded in z around inf 43.5%
Taylor expanded in x around inf 38.3%
associate-*r*39.4%
Simplified39.4%
if 3.3999999999999997e-179 < c < 4.8999999999999999e57Initial program 80.5%
+-commutative80.5%
fma-define80.5%
*-commutative80.5%
*-commutative80.5%
cancel-sign-sub-inv80.5%
cancel-sign-sub80.5%
fmm-def80.5%
distribute-rgt-neg-out80.5%
remove-double-neg80.5%
*-commutative80.5%
*-commutative80.5%
Simplified80.5%
Taylor expanded in i around inf 49.2%
distribute-lft-out--49.2%
*-commutative49.2%
Simplified49.2%
Taylor expanded in y around 0 37.8%
if 4.8999999999999999e57 < c Initial program 70.6%
+-commutative70.6%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
fmm-def74.5%
distribute-rgt-neg-out74.5%
remove-double-neg74.5%
*-commutative74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in c around inf 69.3%
*-commutative69.3%
*-commutative69.3%
Simplified69.3%
Taylor expanded in t around inf 44.4%
associate-*r*48.0%
Simplified48.0%
Final simplification41.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -3.4e-72)
(* j (* t c))
(if (<= c 1.5e-179)
(* x (* y z))
(if (<= c 1.35e+58) (* a (* b i)) (* t (* c 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.4e-72) {
tmp = j * (t * c);
} else if (c <= 1.5e-179) {
tmp = x * (y * z);
} else if (c <= 1.35e+58) {
tmp = a * (b * i);
} else {
tmp = t * (c * 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.4d-72)) then
tmp = j * (t * c)
else if (c <= 1.5d-179) then
tmp = x * (y * z)
else if (c <= 1.35d+58) then
tmp = a * (b * i)
else
tmp = t * (c * 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.4e-72) {
tmp = j * (t * c);
} else if (c <= 1.5e-179) {
tmp = x * (y * z);
} else if (c <= 1.35e+58) {
tmp = a * (b * i);
} else {
tmp = t * (c * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if c <= -3.4e-72: tmp = j * (t * c) elif c <= 1.5e-179: tmp = x * (y * z) elif c <= 1.35e+58: tmp = a * (b * i) else: tmp = t * (c * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -3.4e-72) tmp = Float64(j * Float64(t * c)); elseif (c <= 1.5e-179) tmp = Float64(x * Float64(y * z)); elseif (c <= 1.35e+58) tmp = Float64(a * Float64(b * i)); else tmp = Float64(t * Float64(c * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (c <= -3.4e-72) tmp = j * (t * c); elseif (c <= 1.5e-179) tmp = x * (y * z); elseif (c <= 1.35e+58) tmp = a * (b * i); else tmp = t * (c * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -3.4e-72], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.5e-179], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.35e+58], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -3.4 \cdot 10^{-72}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq 1.5 \cdot 10^{-179}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 1.35 \cdot 10^{+58}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\end{array}
\end{array}
if c < -3.3999999999999998e-72Initial program 69.6%
+-commutative69.6%
fma-define73.4%
*-commutative73.4%
*-commutative73.4%
cancel-sign-sub-inv73.4%
cancel-sign-sub73.4%
fmm-def75.9%
distribute-rgt-neg-out75.9%
remove-double-neg75.9%
*-commutative75.9%
*-commutative75.9%
Simplified75.9%
Taylor expanded in j around inf 57.8%
*-commutative57.8%
*-commutative57.8%
Simplified57.8%
Taylor expanded in t around inf 42.0%
if -3.3999999999999998e-72 < c < 1.50000000000000003e-179Initial program 84.6%
+-commutative84.6%
fma-define84.6%
*-commutative84.6%
*-commutative84.6%
cancel-sign-sub-inv84.6%
cancel-sign-sub84.6%
fmm-def85.9%
distribute-rgt-neg-out85.9%
remove-double-neg85.9%
*-commutative85.9%
*-commutative85.9%
Simplified85.9%
Taylor expanded in y around -inf 72.3%
Simplified75.9%
Taylor expanded in x around inf 59.8%
associate-*r*57.0%
associate-*r/57.0%
associate-*r*57.0%
neg-mul-157.0%
Simplified57.0%
Taylor expanded in y around inf 38.3%
if 1.50000000000000003e-179 < c < 1.3500000000000001e58Initial program 80.5%
+-commutative80.5%
fma-define80.5%
*-commutative80.5%
*-commutative80.5%
cancel-sign-sub-inv80.5%
cancel-sign-sub80.5%
fmm-def80.5%
distribute-rgt-neg-out80.5%
remove-double-neg80.5%
*-commutative80.5%
*-commutative80.5%
Simplified80.5%
Taylor expanded in i around inf 49.2%
distribute-lft-out--49.2%
*-commutative49.2%
Simplified49.2%
Taylor expanded in y around 0 37.8%
if 1.3500000000000001e58 < c Initial program 70.6%
+-commutative70.6%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
fmm-def74.5%
distribute-rgt-neg-out74.5%
remove-double-neg74.5%
*-commutative74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in c around inf 69.3%
*-commutative69.3%
*-commutative69.3%
Simplified69.3%
Taylor expanded in t around inf 44.4%
associate-*r*48.0%
Simplified48.0%
Final simplification41.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= z -3.5e-38)
t_1
(if (<= z -5.2e-186)
(* a (* b i))
(if (<= z 6.6e+91) (* j (* t 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 = x * (y * z);
double tmp;
if (z <= -3.5e-38) {
tmp = t_1;
} else if (z <= -5.2e-186) {
tmp = a * (b * i);
} else if (z <= 6.6e+91) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (z <= (-3.5d-38)) then
tmp = t_1
else if (z <= (-5.2d-186)) then
tmp = a * (b * i)
else if (z <= 6.6d+91) then
tmp = j * (t * 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 = x * (y * z);
double tmp;
if (z <= -3.5e-38) {
tmp = t_1;
} else if (z <= -5.2e-186) {
tmp = a * (b * i);
} else if (z <= 6.6e+91) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if z <= -3.5e-38: tmp = t_1 elif z <= -5.2e-186: tmp = a * (b * i) elif z <= 6.6e+91: tmp = j * (t * c) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (z <= -3.5e-38) tmp = t_1; elseif (z <= -5.2e-186) tmp = Float64(a * Float64(b * i)); elseif (z <= 6.6e+91) tmp = Float64(j * Float64(t * c)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (z <= -3.5e-38) tmp = t_1; elseif (z <= -5.2e-186) tmp = a * (b * i); elseif (z <= 6.6e+91) tmp = j * (t * 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[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.5e-38], t$95$1, If[LessEqual[z, -5.2e-186], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.6e+91], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;z \leq -3.5 \cdot 10^{-38}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq -5.2 \cdot 10^{-186}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;z \leq 6.6 \cdot 10^{+91}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -3.5000000000000001e-38 or 6.60000000000000034e91 < z Initial program 70.4%
+-commutative70.4%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
fmm-def73.7%
distribute-rgt-neg-out73.7%
remove-double-neg73.7%
*-commutative73.7%
*-commutative73.7%
Simplified73.7%
Taylor expanded in y around -inf 69.8%
Simplified70.5%
Taylor expanded in x around inf 54.6%
associate-*r*50.3%
associate-*r/50.3%
associate-*r*50.3%
neg-mul-150.3%
Simplified50.3%
Taylor expanded in y around inf 44.3%
if -3.5000000000000001e-38 < z < -5.19999999999999986e-186Initial program 80.8%
+-commutative80.8%
fma-define80.8%
*-commutative80.8%
*-commutative80.8%
cancel-sign-sub-inv80.8%
cancel-sign-sub80.8%
fmm-def80.8%
distribute-rgt-neg-out80.8%
remove-double-neg80.8%
*-commutative80.8%
*-commutative80.8%
Simplified80.8%
Taylor expanded in i around inf 51.4%
distribute-lft-out--51.4%
*-commutative51.4%
Simplified51.4%
Taylor expanded in y around 0 45.5%
if -5.19999999999999986e-186 < z < 6.60000000000000034e91Initial program 82.1%
+-commutative82.1%
fma-define85.1%
*-commutative85.1%
*-commutative85.1%
cancel-sign-sub-inv85.1%
cancel-sign-sub85.1%
fmm-def86.1%
distribute-rgt-neg-out86.1%
remove-double-neg86.1%
*-commutative86.1%
*-commutative86.1%
Simplified86.1%
Taylor expanded in j around inf 56.5%
*-commutative56.5%
*-commutative56.5%
Simplified56.5%
Taylor expanded in t around inf 35.5%
Final simplification41.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= i -8.2e+111) (not (<= i 9.5e-11))) (* i (- (* a b) (* y j))) (* c (- (* t j) (* z b)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -8.2e+111) || !(i <= 9.5e-11)) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = c * ((t * j) - (z * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((i <= (-8.2d+111)) .or. (.not. (i <= 9.5d-11))) then
tmp = i * ((a * b) - (y * j))
else
tmp = c * ((t * j) - (z * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((i <= -8.2e+111) || !(i <= 9.5e-11)) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = c * ((t * j) - (z * b));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (i <= -8.2e+111) or not (i <= 9.5e-11): tmp = i * ((a * b) - (y * j)) else: tmp = c * ((t * j) - (z * b)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((i <= -8.2e+111) || !(i <= 9.5e-11)) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((i <= -8.2e+111) || ~((i <= 9.5e-11))) tmp = i * ((a * b) - (y * j)); else tmp = c * ((t * j) - (z * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[i, -8.2e+111], N[Not[LessEqual[i, 9.5e-11]], $MachinePrecision]], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -8.2 \cdot 10^{+111} \lor \neg \left(i \leq 9.5 \cdot 10^{-11}\right):\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\end{array}
\end{array}
if i < -8.19999999999999973e111 or 9.49999999999999951e-11 < i Initial program 64.4%
+-commutative64.4%
fma-define65.3%
*-commutative65.3%
*-commutative65.3%
cancel-sign-sub-inv65.3%
cancel-sign-sub65.3%
fmm-def67.1%
distribute-rgt-neg-out67.1%
remove-double-neg67.1%
*-commutative67.1%
*-commutative67.1%
Simplified67.1%
Taylor expanded in i around inf 69.2%
distribute-lft-out--69.2%
*-commutative69.2%
Simplified69.2%
if -8.19999999999999973e111 < i < 9.49999999999999951e-11Initial program 85.9%
+-commutative85.9%
fma-define88.0%
*-commutative88.0%
*-commutative88.0%
cancel-sign-sub-inv88.0%
cancel-sign-sub88.0%
fmm-def89.4%
distribute-rgt-neg-out89.4%
remove-double-neg89.4%
*-commutative89.4%
*-commutative89.4%
Simplified89.4%
Taylor expanded in c around inf 56.0%
*-commutative56.0%
*-commutative56.0%
Simplified56.0%
Final simplification61.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= b -2.85e-36) (not (<= b 5.8e+85))) (* c (- (* t j) (* z b))) (* j (- (* t c) (* y i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -2.85e-36) || !(b <= 5.8e+85)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = j * ((t * c) - (y * i));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((b <= (-2.85d-36)) .or. (.not. (b <= 5.8d+85))) then
tmp = c * ((t * j) - (z * b))
else
tmp = j * ((t * c) - (y * i))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((b <= -2.85e-36) || !(b <= 5.8e+85)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = j * ((t * c) - (y * i));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (b <= -2.85e-36) or not (b <= 5.8e+85): tmp = c * ((t * j) - (z * b)) else: tmp = j * ((t * c) - (y * i)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((b <= -2.85e-36) || !(b <= 5.8e+85)) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((b <= -2.85e-36) || ~((b <= 5.8e+85))) tmp = c * ((t * j) - (z * b)); else tmp = j * ((t * c) - (y * i)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[b, -2.85e-36], N[Not[LessEqual[b, 5.8e+85]], $MachinePrecision]], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.85 \cdot 10^{-36} \lor \neg \left(b \leq 5.8 \cdot 10^{+85}\right):\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\end{array}
\end{array}
if b < -2.8499999999999999e-36 or 5.79999999999999995e85 < b Initial program 75.9%
+-commutative75.9%
fma-define79.5%
*-commutative79.5%
*-commutative79.5%
cancel-sign-sub-inv79.5%
cancel-sign-sub79.5%
fmm-def81.3%
distribute-rgt-neg-out81.3%
remove-double-neg81.3%
*-commutative81.3%
*-commutative81.3%
Simplified81.3%
Taylor expanded in c around inf 56.6%
*-commutative56.6%
*-commutative56.6%
Simplified56.6%
if -2.8499999999999999e-36 < b < 5.79999999999999995e85Initial program 76.8%
+-commutative76.8%
fma-define76.8%
*-commutative76.8%
*-commutative76.8%
cancel-sign-sub-inv76.8%
cancel-sign-sub76.8%
fmm-def78.2%
distribute-rgt-neg-out78.2%
remove-double-neg78.2%
*-commutative78.2%
*-commutative78.2%
Simplified78.2%
Taylor expanded in j around inf 54.4%
*-commutative54.4%
*-commutative54.4%
Simplified54.4%
Final simplification55.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -1.15e+110) (* (* y i) (- (* a (/ b y)) j)) (if (<= i 3.9e-11) (* 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 (i <= -1.15e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 3.9e-11) {
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 (i <= (-1.15d+110)) then
tmp = (y * i) * ((a * (b / y)) - j)
else if (i <= 3.9d-11) 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 (i <= -1.15e+110) {
tmp = (y * i) * ((a * (b / y)) - j);
} else if (i <= 3.9e-11) {
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 i <= -1.15e+110: tmp = (y * i) * ((a * (b / y)) - j) elif i <= 3.9e-11: 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 (i <= -1.15e+110) tmp = Float64(Float64(y * i) * Float64(Float64(a * Float64(b / y)) - j)); elseif (i <= 3.9e-11) 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 (i <= -1.15e+110) tmp = (y * i) * ((a * (b / y)) - j); elseif (i <= 3.9e-11) 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[LessEqual[i, -1.15e+110], N[(N[(y * i), $MachinePrecision] * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.9e-11], 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}\;i \leq -1.15 \cdot 10^{+110}:\\
\;\;\;\;\left(y \cdot i\right) \cdot \left(a \cdot \frac{b}{y} - j\right)\\
\mathbf{elif}\;i \leq 3.9 \cdot 10^{-11}:\\
\;\;\;\;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 i < -1.15e110Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in y around -inf 62.2%
Simplified59.6%
Taylor expanded in i around inf 67.6%
Taylor expanded in i around inf 73.1%
associate-*r*75.4%
associate-/l*77.4%
Simplified77.4%
if -1.15e110 < i < 3.9000000000000001e-11Initial program 85.9%
+-commutative85.9%
fma-define88.0%
*-commutative88.0%
*-commutative88.0%
cancel-sign-sub-inv88.0%
cancel-sign-sub88.0%
fmm-def89.4%
distribute-rgt-neg-out89.4%
remove-double-neg89.4%
*-commutative89.4%
*-commutative89.4%
Simplified89.4%
Taylor expanded in c around inf 56.0%
*-commutative56.0%
*-commutative56.0%
Simplified56.0%
if 3.9000000000000001e-11 < i Initial program 71.8%
+-commutative71.8%
fma-define71.8%
*-commutative71.8%
*-commutative71.8%
cancel-sign-sub-inv71.8%
cancel-sign-sub71.8%
fmm-def74.5%
distribute-rgt-neg-out74.5%
remove-double-neg74.5%
*-commutative74.5%
*-commutative74.5%
Simplified74.5%
Taylor expanded in i around inf 68.5%
distribute-lft-out--68.5%
*-commutative68.5%
Simplified68.5%
Final simplification62.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= i -1.9e+110) (not (<= i 2.5e-20))) (* 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 <= -1.9e+110) || !(i <= 2.5e-20)) {
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 <= (-1.9d+110)) .or. (.not. (i <= 2.5d-20))) 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 <= -1.9e+110) || !(i <= 2.5e-20)) {
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 <= -1.9e+110) or not (i <= 2.5e-20): 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 <= -1.9e+110) || !(i <= 2.5e-20)) 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 <= -1.9e+110) || ~((i <= 2.5e-20))) 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, -1.9e+110], N[Not[LessEqual[i, 2.5e-20]], $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 -1.9 \cdot 10^{+110} \lor \neg \left(i \leq 2.5 \cdot 10^{-20}\right):\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if i < -1.89999999999999994e110 or 2.4999999999999999e-20 < i Initial program 63.9%
+-commutative63.9%
fma-define65.6%
*-commutative65.6%
*-commutative65.6%
cancel-sign-sub-inv65.6%
cancel-sign-sub65.6%
fmm-def67.3%
distribute-rgt-neg-out67.3%
remove-double-neg67.3%
*-commutative67.3%
*-commutative67.3%
Simplified67.3%
Taylor expanded in i around inf 67.7%
distribute-lft-out--67.7%
*-commutative67.7%
Simplified67.7%
Taylor expanded in y around 0 41.1%
if -1.89999999999999994e110 < i < 2.4999999999999999e-20Initial program 86.9%
+-commutative86.9%
fma-define88.3%
*-commutative88.3%
*-commutative88.3%
cancel-sign-sub-inv88.3%
cancel-sign-sub88.3%
fmm-def89.8%
distribute-rgt-neg-out89.8%
remove-double-neg89.8%
*-commutative89.8%
*-commutative89.8%
Simplified89.8%
Taylor expanded in c around inf 56.1%
*-commutative56.1%
*-commutative56.1%
Simplified56.1%
Taylor expanded in t around inf 36.2%
Final simplification38.4%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -8.2e+111) (* a (* b i)) (if (<= i 1.3e-20) (* j (* t c)) (* 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 <= -8.2e+111) {
tmp = a * (b * i);
} else if (i <= 1.3e-20) {
tmp = j * (t * c);
} 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 <= (-8.2d+111)) then
tmp = a * (b * i)
else if (i <= 1.3d-20) then
tmp = j * (t * c)
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 <= -8.2e+111) {
tmp = a * (b * i);
} else if (i <= 1.3e-20) {
tmp = j * (t * c);
} else {
tmp = i * (a * b);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if i <= -8.2e+111: tmp = a * (b * i) elif i <= 1.3e-20: tmp = j * (t * c) else: tmp = i * (a * b) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -8.2e+111) tmp = Float64(a * Float64(b * i)); elseif (i <= 1.3e-20) tmp = Float64(j * Float64(t * c)); 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 <= -8.2e+111) tmp = a * (b * i); elseif (i <= 1.3e-20) tmp = j * (t * c); else tmp = i * (a * b); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -8.2e+111], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.3e-20], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -8.2 \cdot 10^{+111}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq 1.3 \cdot 10^{-20}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if i < -8.19999999999999973e111Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in i around inf 70.5%
distribute-lft-out--70.5%
*-commutative70.5%
Simplified70.5%
Taylor expanded in y around 0 47.8%
if -8.19999999999999973e111 < i < 1.29999999999999997e-20Initial program 86.9%
+-commutative86.9%
fma-define88.3%
*-commutative88.3%
*-commutative88.3%
cancel-sign-sub-inv88.3%
cancel-sign-sub88.3%
fmm-def89.8%
distribute-rgt-neg-out89.8%
remove-double-neg89.8%
*-commutative89.8%
*-commutative89.8%
Simplified89.8%
Taylor expanded in j around inf 43.7%
*-commutative43.7%
*-commutative43.7%
Simplified43.7%
Taylor expanded in t around inf 37.5%
if 1.29999999999999997e-20 < i Initial program 70.7%
+-commutative70.7%
fma-define72.0%
*-commutative72.0%
*-commutative72.0%
cancel-sign-sub-inv72.0%
cancel-sign-sub72.0%
fmm-def74.6%
distribute-rgt-neg-out74.6%
remove-double-neg74.6%
*-commutative74.6%
*-commutative74.6%
Simplified74.6%
Taylor expanded in i around inf 66.3%
distribute-lft-out--66.3%
*-commutative66.3%
Simplified66.3%
Taylor expanded in y around 0 37.7%
Final simplification39.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= i -1.35e+110) (* a (* b i)) (if (<= i 2.5e-20) (* 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.35e+110) {
tmp = a * (b * i);
} else if (i <= 2.5e-20) {
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.35d+110)) then
tmp = a * (b * i)
else if (i <= 2.5d-20) 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.35e+110) {
tmp = a * (b * i);
} else if (i <= 2.5e-20) {
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.35e+110: tmp = a * (b * i) elif i <= 2.5e-20: 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.35e+110) tmp = Float64(a * Float64(b * i)); elseif (i <= 2.5e-20) 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.35e+110) tmp = a * (b * i); elseif (i <= 2.5e-20) 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.35e+110], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.5e-20], 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.35 \cdot 10^{+110}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;i \leq 2.5 \cdot 10^{-20}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if i < -1.35000000000000005e110Initial program 50.4%
+-commutative50.4%
fma-define52.9%
*-commutative52.9%
*-commutative52.9%
cancel-sign-sub-inv52.9%
cancel-sign-sub52.9%
fmm-def52.9%
distribute-rgt-neg-out52.9%
remove-double-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Taylor expanded in i around inf 70.5%
distribute-lft-out--70.5%
*-commutative70.5%
Simplified70.5%
Taylor expanded in y around 0 47.8%
if -1.35000000000000005e110 < i < 2.4999999999999999e-20Initial program 86.9%
+-commutative86.9%
fma-define88.3%
*-commutative88.3%
*-commutative88.3%
cancel-sign-sub-inv88.3%
cancel-sign-sub88.3%
fmm-def89.8%
distribute-rgt-neg-out89.8%
remove-double-neg89.8%
*-commutative89.8%
*-commutative89.8%
Simplified89.8%
Taylor expanded in c around inf 56.1%
*-commutative56.1%
*-commutative56.1%
Simplified56.1%
Taylor expanded in t around inf 36.2%
if 2.4999999999999999e-20 < i Initial program 70.7%
+-commutative70.7%
fma-define72.0%
*-commutative72.0%
*-commutative72.0%
cancel-sign-sub-inv72.0%
cancel-sign-sub72.0%
fmm-def74.6%
distribute-rgt-neg-out74.6%
remove-double-neg74.6%
*-commutative74.6%
*-commutative74.6%
Simplified74.6%
Taylor expanded in i around inf 66.3%
distribute-lft-out--66.3%
*-commutative66.3%
Simplified66.3%
Taylor expanded in y around 0 37.7%
Final simplification38.4%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* b i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = a * (b * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
def code(x, y, z, t, a, b, c, i, j): return a * (b * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(b * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (b * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(b \cdot i\right)
\end{array}
Initial program 76.4%
+-commutative76.4%
fma-define78.0%
*-commutative78.0%
*-commutative78.0%
cancel-sign-sub-inv78.0%
cancel-sign-sub78.0%
fmm-def79.5%
distribute-rgt-neg-out79.5%
remove-double-neg79.5%
*-commutative79.5%
*-commutative79.5%
Simplified79.5%
Taylor expanded in i around inf 38.3%
distribute-lft-out--38.3%
*-commutative38.3%
Simplified38.3%
Taylor expanded in y around 0 23.0%
(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 2024172
(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)))))