
(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 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* b (- (* a i) (* z c))) (* x (- (* t a) (* y z)))))
(t_2 (- (* t c) (* y i))))
(if (<= (+ t_1 (* j t_2)) INFINITY)
(fma j t_2 t_1)
(fma i (- (* a b) (* y j)) (* z (fma x y (* b (- c))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)));
double t_2 = (t * c) - (y * i);
double tmp;
if ((t_1 + (j * t_2)) <= ((double) INFINITY)) {
tmp = fma(j, t_2, t_1);
} else {
tmp = fma(i, ((a * b) - (y * j)), (z * fma(x, y, (b * -c))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) t_2 = Float64(Float64(t * c) - Float64(y * i)) tmp = 0.0 if (Float64(t_1 + Float64(j * t_2)) <= Inf) tmp = fma(j, t_2, t_1); else tmp = fma(i, Float64(Float64(a * b) - Float64(y * j)), Float64(z * fma(x, y, Float64(b * Float64(-c))))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$1 + N[(j * t$95$2), $MachinePrecision]), $MachinePrecision], Infinity], N[(j * t$95$2 + t$95$1), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision] + N[(z * N[(x * y + N[(b * (-c)), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right) - x \cdot \left(t \cdot a - y \cdot z\right)\\
t_2 := t \cdot c - y \cdot i\\
\mathbf{if}\;t_1 + j \cdot t_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(j, t_2, t_1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(i, a \cdot b - y \cdot j, z \cdot \mathsf{fma}\left(x, y, b \cdot \left(-c\right)\right)\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 92.2%
+-commutative92.2%
fma-def92.2%
*-commutative92.2%
*-commutative92.2%
cancel-sign-sub-inv92.2%
cancel-sign-sub92.2%
remove-double-neg92.2%
*-commutative92.2%
*-commutative92.2%
Simplified92.2%
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-def8.9%
*-commutative8.9%
*-commutative8.9%
cancel-sign-sub-inv8.9%
cancel-sign-sub8.9%
remove-double-neg8.9%
*-commutative8.9%
*-commutative8.9%
Simplified8.9%
Taylor expanded in z around 0 46.4%
+-commutative46.4%
associate--l+46.4%
sub-neg46.4%
sub-neg46.4%
associate-*r*46.4%
associate-*r*46.4%
distribute-lft-out--50.0%
associate-*r*50.0%
+-commutative50.0%
*-commutative50.0%
associate-*l*50.0%
*-commutative50.0%
distribute-lft-out--50.0%
Simplified51.8%
Taylor expanded in t around 0 50.4%
associate-*r*45.0%
*-commutative45.0%
associate-+l+45.0%
mul-1-neg45.0%
distribute-rgt-neg-in45.0%
mul-1-neg45.0%
distribute-lft-in53.9%
fma-def61.1%
+-commutative61.1%
mul-1-neg61.1%
unsub-neg61.1%
*-commutative61.1%
fma-neg61.1%
*-commutative61.1%
distribute-rgt-neg-in61.1%
Simplified61.1%
Final simplification85.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* b (- (* a i) (* z c))) (* x (- (* t a) (* y z)))))
(t_2 (- (* t c) (* y i))))
(if (<= (+ t_1 (* j t_2)) INFINITY)
(fma j t_2 t_1)
(* c (- (* t j) (* z b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)));
double t_2 = (t * c) - (y * i);
double tmp;
if ((t_1 + (j * t_2)) <= ((double) INFINITY)) {
tmp = fma(j, t_2, t_1);
} else {
tmp = c * ((t * j) - (z * b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) t_2 = Float64(Float64(t * c) - Float64(y * i)) tmp = 0.0 if (Float64(t_1 + Float64(j * t_2)) <= Inf) tmp = fma(j, t_2, t_1); else tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$1 + N[(j * t$95$2), $MachinePrecision]), $MachinePrecision], Infinity], N[(j * t$95$2 + t$95$1), $MachinePrecision], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right) - x \cdot \left(t \cdot a - y \cdot z\right)\\
t_2 := t \cdot c - y \cdot i\\
\mathbf{if}\;t_1 + j \cdot t_2 \leq \infty:\\
\;\;\;\;\mathsf{fma}\left(j, t_2, t_1\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 92.2%
+-commutative92.2%
fma-def92.2%
*-commutative92.2%
*-commutative92.2%
cancel-sign-sub-inv92.2%
cancel-sign-sub92.2%
remove-double-neg92.2%
*-commutative92.2%
*-commutative92.2%
Simplified92.2%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in c around inf 54.1%
*-commutative54.1%
*-commutative54.1%
Simplified54.1%
Final simplification83.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* b (- (* a i) (* z c))) (* x (- (* t a) (* y z))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* c (- (* t j) (* z b))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = c * ((t * j) - (z * b));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = c * ((t * j) - (z * b));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = c * ((t * j) - (z * b)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(b * Float64(Float64(a * i) - Float64(z * c))) - Float64(x * Float64(Float64(t * a) - Float64(y * z)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((b * ((a * i) - (z * c))) - (x * ((t * a) - (y * z)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = c * ((t * j) - (z * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * N[(N[(t * a), $MachinePrecision] - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(b \cdot \left(a \cdot i - z \cdot c\right) - x \cdot \left(t \cdot a - y \cdot z\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t_1 \leq \infty:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\end{array}
\end{array}
if (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) < +inf.0Initial program 92.2%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
Taylor expanded in c around inf 54.1%
*-commutative54.1%
*-commutative54.1%
Simplified54.1%
Final simplification83.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -3e+208)
t_1
(if (<= c -1.45e+178)
(* x (- (* y z) (* t a)))
(if (<= c -4.2e+134)
t_1
(if (<= c 5.5e+15)
(+ (* y (- (* x z) (* i j))) (* a (- (* b i) (* x t))))
(if (<= c 1.35e+156)
(+ (* t (* c j)) (* b (- (* a i) (* z 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 = c * ((t * j) - (z * b));
double tmp;
if (c <= -3e+208) {
tmp = t_1;
} else if (c <= -1.45e+178) {
tmp = x * ((y * z) - (t * a));
} else if (c <= -4.2e+134) {
tmp = t_1;
} else if (c <= 5.5e+15) {
tmp = (y * ((x * z) - (i * j))) + (a * ((b * i) - (x * t)));
} else if (c <= 1.35e+156) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * 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 = c * ((t * j) - (z * b))
if (c <= (-3d+208)) then
tmp = t_1
else if (c <= (-1.45d+178)) then
tmp = x * ((y * z) - (t * a))
else if (c <= (-4.2d+134)) then
tmp = t_1
else if (c <= 5.5d+15) then
tmp = (y * ((x * z) - (i * j))) + (a * ((b * i) - (x * t)))
else if (c <= 1.35d+156) then
tmp = (t * (c * j)) + (b * ((a * i) - (z * 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 = c * ((t * j) - (z * b));
double tmp;
if (c <= -3e+208) {
tmp = t_1;
} else if (c <= -1.45e+178) {
tmp = x * ((y * z) - (t * a));
} else if (c <= -4.2e+134) {
tmp = t_1;
} else if (c <= 5.5e+15) {
tmp = (y * ((x * z) - (i * j))) + (a * ((b * i) - (x * t)));
} else if (c <= 1.35e+156) {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
} 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 <= -3e+208: tmp = t_1 elif c <= -1.45e+178: tmp = x * ((y * z) - (t * a)) elif c <= -4.2e+134: tmp = t_1 elif c <= 5.5e+15: tmp = (y * ((x * z) - (i * j))) + (a * ((b * i) - (x * t))) elif c <= 1.35e+156: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) 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 <= -3e+208) tmp = t_1; elseif (c <= -1.45e+178) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (c <= -4.2e+134) tmp = t_1; elseif (c <= 5.5e+15) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + Float64(a * Float64(Float64(b * i) - Float64(x * t)))); elseif (c <= 1.35e+156) tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); 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 <= -3e+208) tmp = t_1; elseif (c <= -1.45e+178) tmp = x * ((y * z) - (t * a)); elseif (c <= -4.2e+134) tmp = t_1; elseif (c <= 5.5e+15) tmp = (y * ((x * z) - (i * j))) + (a * ((b * i) - (x * t))); elseif (c <= 1.35e+156) tmp = (t * (c * j)) + (b * ((a * i) - (z * 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[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3e+208], t$95$1, If[LessEqual[c, -1.45e+178], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -4.2e+134], t$95$1, If[LessEqual[c, 5.5e+15], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.35e+156], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -3 \cdot 10^{+208}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -1.45 \cdot 10^{+178}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;c \leq -4.2 \cdot 10^{+134}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq 5.5 \cdot 10^{+15}:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;c \leq 1.35 \cdot 10^{+156}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -2.99999999999999995e208 or -1.45e178 < c < -4.2000000000000002e134 or 1.35e156 < c Initial program 64.7%
Taylor expanded in c around inf 88.7%
*-commutative88.7%
*-commutative88.7%
Simplified88.7%
if -2.99999999999999995e208 < c < -1.45e178Initial program 16.5%
+-commutative16.5%
fma-def16.5%
*-commutative16.5%
*-commutative16.5%
cancel-sign-sub-inv16.5%
cancel-sign-sub16.5%
remove-double-neg16.5%
*-commutative16.5%
*-commutative16.5%
Simplified16.5%
Taylor expanded in z around 0 57.1%
+-commutative57.1%
associate--l+57.1%
sub-neg57.1%
sub-neg57.1%
associate-*r*57.1%
associate-*r*57.1%
distribute-lft-out--57.1%
associate-*r*57.1%
+-commutative57.1%
*-commutative57.1%
associate-*l*57.1%
*-commutative57.1%
distribute-lft-out--57.1%
Simplified57.1%
Taylor expanded in x around inf 86.3%
+-commutative86.3%
mul-1-neg86.3%
unsub-neg86.3%
*-commutative86.3%
Simplified86.3%
if -4.2000000000000002e134 < c < 5.5e15Initial program 75.0%
+-commutative75.0%
fma-def77.0%
*-commutative77.0%
*-commutative77.0%
cancel-sign-sub-inv77.0%
cancel-sign-sub77.0%
remove-double-neg77.0%
*-commutative77.0%
*-commutative77.0%
Simplified77.0%
Taylor expanded in z around 0 81.3%
+-commutative81.3%
associate--l+81.3%
sub-neg81.3%
sub-neg81.3%
associate-*r*81.3%
associate-*r*81.3%
distribute-lft-out--82.0%
associate-*r*82.0%
+-commutative82.0%
*-commutative82.0%
associate-*l*82.0%
*-commutative82.0%
distribute-lft-out--82.0%
Simplified82.7%
Taylor expanded in c around 0 71.9%
+-commutative71.9%
associate-+l+71.9%
*-commutative71.9%
associate-*l*71.4%
mul-1-neg71.4%
associate-*r*74.0%
*-commutative74.0%
distribute-lft-neg-out74.0%
distribute-rgt-in74.6%
neg-mul-174.6%
*-commutative74.6%
mul-1-neg74.6%
unsub-neg74.6%
Simplified74.6%
if 5.5e15 < c < 1.35e156Initial program 89.4%
Taylor expanded in y around 0 78.4%
*-commutative78.4%
*-commutative78.4%
*-commutative78.4%
*-rgt-identity78.4%
cancel-sign-sub-inv78.4%
Simplified78.0%
Taylor expanded in j around inf 78.0%
Final simplification79.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* z (- c)))) (t_2 (* j (* t c))))
(if (<= c -5.5e+145)
t_2
(if (<= c -3.1e+40)
t_1
(if (<= c -2.8e+34)
(* (* x t) (- a))
(if (<= c -5e-213)
(* x (* y z))
(if (<= c 3.2e-85)
(* b (* a i))
(if (<= c 5.8e+45)
(* y (* i (- j)))
(if (<= c 6.2e+103)
t_2
(if (or (<= c 1.8e+153) (not (<= c 5.8e+227)))
t_1
(* c (* t j))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = j * (t * c);
double tmp;
if (c <= -5.5e+145) {
tmp = t_2;
} else if (c <= -3.1e+40) {
tmp = t_1;
} else if (c <= -2.8e+34) {
tmp = (x * t) * -a;
} else if (c <= -5e-213) {
tmp = x * (y * z);
} else if (c <= 3.2e-85) {
tmp = b * (a * i);
} else if (c <= 5.8e+45) {
tmp = y * (i * -j);
} else if (c <= 6.2e+103) {
tmp = t_2;
} else if ((c <= 1.8e+153) || !(c <= 5.8e+227)) {
tmp = t_1;
} 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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = b * (z * -c)
t_2 = j * (t * c)
if (c <= (-5.5d+145)) then
tmp = t_2
else if (c <= (-3.1d+40)) then
tmp = t_1
else if (c <= (-2.8d+34)) then
tmp = (x * t) * -a
else if (c <= (-5d-213)) then
tmp = x * (y * z)
else if (c <= 3.2d-85) then
tmp = b * (a * i)
else if (c <= 5.8d+45) then
tmp = y * (i * -j)
else if (c <= 6.2d+103) then
tmp = t_2
else if ((c <= 1.8d+153) .or. (.not. (c <= 5.8d+227))) then
tmp = t_1
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 t_1 = b * (z * -c);
double t_2 = j * (t * c);
double tmp;
if (c <= -5.5e+145) {
tmp = t_2;
} else if (c <= -3.1e+40) {
tmp = t_1;
} else if (c <= -2.8e+34) {
tmp = (x * t) * -a;
} else if (c <= -5e-213) {
tmp = x * (y * z);
} else if (c <= 3.2e-85) {
tmp = b * (a * i);
} else if (c <= 5.8e+45) {
tmp = y * (i * -j);
} else if (c <= 6.2e+103) {
tmp = t_2;
} else if ((c <= 1.8e+153) || !(c <= 5.8e+227)) {
tmp = t_1;
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (z * -c) t_2 = j * (t * c) tmp = 0 if c <= -5.5e+145: tmp = t_2 elif c <= -3.1e+40: tmp = t_1 elif c <= -2.8e+34: tmp = (x * t) * -a elif c <= -5e-213: tmp = x * (y * z) elif c <= 3.2e-85: tmp = b * (a * i) elif c <= 5.8e+45: tmp = y * (i * -j) elif c <= 6.2e+103: tmp = t_2 elif (c <= 1.8e+153) or not (c <= 5.8e+227): tmp = t_1 else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(z * Float64(-c))) t_2 = Float64(j * Float64(t * c)) tmp = 0.0 if (c <= -5.5e+145) tmp = t_2; elseif (c <= -3.1e+40) tmp = t_1; elseif (c <= -2.8e+34) tmp = Float64(Float64(x * t) * Float64(-a)); elseif (c <= -5e-213) tmp = Float64(x * Float64(y * z)); elseif (c <= 3.2e-85) tmp = Float64(b * Float64(a * i)); elseif (c <= 5.8e+45) tmp = Float64(y * Float64(i * Float64(-j))); elseif (c <= 6.2e+103) tmp = t_2; elseif ((c <= 1.8e+153) || !(c <= 5.8e+227)) tmp = t_1; else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (z * -c); t_2 = j * (t * c); tmp = 0.0; if (c <= -5.5e+145) tmp = t_2; elseif (c <= -3.1e+40) tmp = t_1; elseif (c <= -2.8e+34) tmp = (x * t) * -a; elseif (c <= -5e-213) tmp = x * (y * z); elseif (c <= 3.2e-85) tmp = b * (a * i); elseif (c <= 5.8e+45) tmp = y * (i * -j); elseif (c <= 6.2e+103) tmp = t_2; elseif ((c <= 1.8e+153) || ~((c <= 5.8e+227))) tmp = t_1; else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -5.5e+145], t$95$2, If[LessEqual[c, -3.1e+40], t$95$1, If[LessEqual[c, -2.8e+34], N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision], If[LessEqual[c, -5e-213], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.2e-85], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5.8e+45], N[(y * N[(i * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.2e+103], t$95$2, If[Or[LessEqual[c, 1.8e+153], N[Not[LessEqual[c, 5.8e+227]], $MachinePrecision]], t$95$1, N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(z \cdot \left(-c\right)\right)\\
t_2 := j \cdot \left(t \cdot c\right)\\
\mathbf{if}\;c \leq -5.5 \cdot 10^{+145}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -3.1 \cdot 10^{+40}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -2.8 \cdot 10^{+34}:\\
\;\;\;\;\left(x \cdot t\right) \cdot \left(-a\right)\\
\mathbf{elif}\;c \leq -5 \cdot 10^{-213}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 3.2 \cdot 10^{-85}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;c \leq 5.8 \cdot 10^{+45}:\\
\;\;\;\;y \cdot \left(i \cdot \left(-j\right)\right)\\
\mathbf{elif}\;c \leq 6.2 \cdot 10^{+103}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq 1.8 \cdot 10^{+153} \lor \neg \left(c \leq 5.8 \cdot 10^{+227}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if c < -5.4999999999999995e145 or 5.7999999999999994e45 < c < 6.2000000000000003e103Initial program 52.0%
Taylor expanded in c around inf 65.6%
*-commutative65.6%
*-commutative65.6%
Simplified65.6%
Taylor expanded in t around inf 44.2%
*-commutative44.2%
*-commutative44.2%
*-commutative44.2%
associate-*r*49.3%
Simplified49.3%
if -5.4999999999999995e145 < c < -3.0999999999999998e40 or 6.2000000000000003e103 < c < 1.8e153 or 5.7999999999999997e227 < c Initial program 75.0%
Taylor expanded in y around 0 77.2%
*-commutative77.2%
*-commutative77.2%
*-commutative77.2%
*-rgt-identity77.2%
cancel-sign-sub-inv77.2%
Simplified74.1%
Taylor expanded in j around inf 75.6%
Taylor expanded in z around inf 53.1%
mul-1-neg53.1%
*-commutative53.1%
Simplified53.1%
if -3.0999999999999998e40 < c < -2.80000000000000008e34Initial program 100.0%
Taylor expanded in a around inf 100.0%
associate-*r*100.0%
neg-mul-1100.0%
cancel-sign-sub100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
*-commutative100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in i around 0 100.0%
neg-mul-1100.0%
distribute-rgt-neg-in100.0%
Simplified100.0%
if -2.80000000000000008e34 < c < -4.99999999999999977e-213Initial program 75.5%
+-commutative75.5%
fma-def77.7%
*-commutative77.7%
*-commutative77.7%
cancel-sign-sub-inv77.7%
cancel-sign-sub77.7%
remove-double-neg77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Taylor expanded in z around 0 82.4%
+-commutative82.4%
associate--l+82.4%
sub-neg82.4%
sub-neg82.4%
associate-*r*82.4%
associate-*r*82.4%
distribute-lft-out--84.6%
associate-*r*84.6%
+-commutative84.6%
*-commutative84.6%
associate-*l*84.6%
*-commutative84.6%
distribute-lft-out--84.6%
Simplified86.9%
Taylor expanded in x around inf 60.8%
+-commutative60.8%
mul-1-neg60.8%
unsub-neg60.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in z around inf 47.7%
if -4.99999999999999977e-213 < c < 3.20000000000000027e-85Initial program 77.7%
Taylor expanded in y around 0 60.8%
*-commutative60.8%
*-commutative60.8%
*-commutative60.8%
*-rgt-identity60.8%
cancel-sign-sub-inv60.8%
Simplified62.5%
Taylor expanded in j around inf 42.1%
Taylor expanded in c around 0 35.9%
associate-*r*34.5%
*-commutative34.5%
associate-*l*38.9%
Simplified38.9%
if 3.20000000000000027e-85 < c < 5.7999999999999994e45Initial program 83.0%
Taylor expanded in j around inf 51.3%
Taylor expanded in c around 0 35.5%
mul-1-neg35.5%
*-commutative35.5%
distribute-rgt-neg-in35.5%
*-commutative35.5%
Simplified35.5%
Taylor expanded in y around 0 35.5%
*-commutative35.5%
*-commutative35.5%
neg-mul-135.5%
distribute-rgt-neg-in35.5%
associate-*r*31.7%
Simplified31.7%
if 1.8e153 < c < 5.7999999999999997e227Initial program 59.9%
Taylor expanded in j around inf 53.3%
Taylor expanded in c around inf 54.6%
*-commutative54.6%
Simplified54.6%
Final simplification46.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* c (- (* t j) (* z b)))))
(if (<= c -4.2e+133)
t_2
(if (<= c -8.6e+70)
t_1
(if (<= c -4.9e+29)
t_2
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 4e-83)
(* a (- (* b i) (* x t)))
(if (<= c 3.5e+98)
(* j (- (* t c) (* y i)))
(if (<= c 6.3e+106) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((a * b) - (y * j));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -4.2e+133) {
tmp = t_2;
} else if (c <= -8.6e+70) {
tmp = t_1;
} else if (c <= -4.9e+29) {
tmp = t_2;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 4e-83) {
tmp = a * ((b * i) - (x * t));
} else if (c <= 3.5e+98) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 6.3e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = i * ((a * b) - (y * j))
t_2 = c * ((t * j) - (z * b))
if (c <= (-4.2d+133)) then
tmp = t_2
else if (c <= (-8.6d+70)) then
tmp = t_1
else if (c <= (-4.9d+29)) then
tmp = t_2
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 4d-83) then
tmp = a * ((b * i) - (x * t))
else if (c <= 3.5d+98) then
tmp = j * ((t * c) - (y * i))
else if (c <= 6.3d+106) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((a * b) - (y * j));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -4.2e+133) {
tmp = t_2;
} else if (c <= -8.6e+70) {
tmp = t_1;
} else if (c <= -4.9e+29) {
tmp = t_2;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 4e-83) {
tmp = a * ((b * i) - (x * t));
} else if (c <= 3.5e+98) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 6.3e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((a * b) - (y * j)) t_2 = c * ((t * j) - (z * b)) tmp = 0 if c <= -4.2e+133: tmp = t_2 elif c <= -8.6e+70: tmp = t_1 elif c <= -4.9e+29: tmp = t_2 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 4e-83: tmp = a * ((b * i) - (x * t)) elif c <= 3.5e+98: tmp = j * ((t * c) - (y * i)) elif c <= 6.3e+106: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) t_2 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -4.2e+133) tmp = t_2; elseif (c <= -8.6e+70) tmp = t_1; elseif (c <= -4.9e+29) tmp = t_2; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 4e-83) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (c <= 3.5e+98) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (c <= 6.3e+106) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * ((a * b) - (y * j)); t_2 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -4.2e+133) tmp = t_2; elseif (c <= -8.6e+70) tmp = t_1; elseif (c <= -4.9e+29) tmp = t_2; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 4e-83) tmp = a * ((b * i) - (x * t)); elseif (c <= 3.5e+98) tmp = j * ((t * c) - (y * i)); elseif (c <= 6.3e+106) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -4.2e+133], t$95$2, If[LessEqual[c, -8.6e+70], t$95$1, If[LessEqual[c, -4.9e+29], t$95$2, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4e-83], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.5e+98], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.3e+106], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
t_2 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -4.2 \cdot 10^{+133}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -8.6 \cdot 10^{+70}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -4.9 \cdot 10^{+29}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 4 \cdot 10^{-83}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;c \leq 3.5 \cdot 10^{+98}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;c \leq 6.3 \cdot 10^{+106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if c < -4.2e133 or -8.6000000000000002e70 < c < -4.9000000000000001e29 or 6.29999999999999974e106 < c Initial program 65.1%
Taylor expanded in c around inf 79.2%
*-commutative79.2%
*-commutative79.2%
Simplified79.2%
if -4.2e133 < c < -8.6000000000000002e70 or 3.5e98 < c < 6.29999999999999974e106Initial program 60.9%
Taylor expanded in i around inf 63.6%
cancel-sign-sub-inv63.6%
metadata-eval63.6%
*-lft-identity63.6%
+-commutative63.6%
mul-1-neg63.6%
unsub-neg63.6%
*-commutative63.6%
Simplified63.6%
if -4.9000000000000001e29 < c < -5.60000000000000023e-141Initial program 70.9%
+-commutative70.9%
fma-def74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 80.9%
+-commutative80.9%
associate--l+80.9%
sub-neg80.9%
sub-neg80.9%
associate-*r*80.9%
associate-*r*80.9%
distribute-lft-out--84.1%
associate-*r*84.1%
+-commutative84.1%
*-commutative84.1%
associate-*l*84.1%
*-commutative84.1%
distribute-lft-out--84.1%
Simplified87.4%
Taylor expanded in x around inf 58.8%
+-commutative58.8%
mul-1-neg58.8%
unsub-neg58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in z around inf 52.7%
if -5.60000000000000023e-141 < c < 4.0000000000000001e-83Initial program 78.1%
Taylor expanded in a around inf 58.4%
associate-*r*58.4%
neg-mul-158.4%
cancel-sign-sub58.4%
+-commutative58.4%
mul-1-neg58.4%
unsub-neg58.4%
*-commutative58.4%
*-commutative58.4%
Simplified58.4%
if 4.0000000000000001e-83 < c < 3.5e98Initial program 89.0%
Taylor expanded in j around inf 54.7%
Final simplification66.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* c (- (* t j) (* z b)))))
(if (<= c -3.4e+131)
t_2
(if (<= c -2.25e+74)
t_1
(if (<= c -4.4e+29)
t_2
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 1e-81)
(* a (- (* b i) (* x t)))
(if (<= c 6.3e+97)
(* t (- (* c j) (* x a)))
(if (<= c 6.3e+106) t_1 t_2)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((a * b) - (y * j));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -3.4e+131) {
tmp = t_2;
} else if (c <= -2.25e+74) {
tmp = t_1;
} else if (c <= -4.4e+29) {
tmp = t_2;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 1e-81) {
tmp = a * ((b * i) - (x * t));
} else if (c <= 6.3e+97) {
tmp = t * ((c * j) - (x * a));
} else if (c <= 6.3e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = i * ((a * b) - (y * j))
t_2 = c * ((t * j) - (z * b))
if (c <= (-3.4d+131)) then
tmp = t_2
else if (c <= (-2.25d+74)) then
tmp = t_1
else if (c <= (-4.4d+29)) then
tmp = t_2
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 1d-81) then
tmp = a * ((b * i) - (x * t))
else if (c <= 6.3d+97) then
tmp = t * ((c * j) - (x * a))
else if (c <= 6.3d+106) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((a * b) - (y * j));
double t_2 = c * ((t * j) - (z * b));
double tmp;
if (c <= -3.4e+131) {
tmp = t_2;
} else if (c <= -2.25e+74) {
tmp = t_1;
} else if (c <= -4.4e+29) {
tmp = t_2;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 1e-81) {
tmp = a * ((b * i) - (x * t));
} else if (c <= 6.3e+97) {
tmp = t * ((c * j) - (x * a));
} else if (c <= 6.3e+106) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((a * b) - (y * j)) t_2 = c * ((t * j) - (z * b)) tmp = 0 if c <= -3.4e+131: tmp = t_2 elif c <= -2.25e+74: tmp = t_1 elif c <= -4.4e+29: tmp = t_2 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 1e-81: tmp = a * ((b * i) - (x * t)) elif c <= 6.3e+97: tmp = t * ((c * j) - (x * a)) elif c <= 6.3e+106: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) t_2 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -3.4e+131) tmp = t_2; elseif (c <= -2.25e+74) tmp = t_1; elseif (c <= -4.4e+29) tmp = t_2; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 1e-81) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); elseif (c <= 6.3e+97) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (c <= 6.3e+106) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * ((a * b) - (y * j)); t_2 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -3.4e+131) tmp = t_2; elseif (c <= -2.25e+74) tmp = t_1; elseif (c <= -4.4e+29) tmp = t_2; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 1e-81) tmp = a * ((b * i) - (x * t)); elseif (c <= 6.3e+97) tmp = t * ((c * j) - (x * a)); elseif (c <= 6.3e+106) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.4e+131], t$95$2, If[LessEqual[c, -2.25e+74], t$95$1, If[LessEqual[c, -4.4e+29], t$95$2, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1e-81], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.3e+97], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.3e+106], t$95$1, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
t_2 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -3.4 \cdot 10^{+131}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -2.25 \cdot 10^{+74}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -4.4 \cdot 10^{+29}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 10^{-81}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{elif}\;c \leq 6.3 \cdot 10^{+97}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;c \leq 6.3 \cdot 10^{+106}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if c < -3.39999999999999986e131 or -2.25e74 < c < -4.4000000000000003e29 or 6.29999999999999974e106 < c Initial program 65.1%
Taylor expanded in c around inf 79.2%
*-commutative79.2%
*-commutative79.2%
Simplified79.2%
if -3.39999999999999986e131 < c < -2.25e74 or 6.29999999999999997e97 < c < 6.29999999999999974e106Initial program 60.9%
Taylor expanded in i around inf 63.6%
cancel-sign-sub-inv63.6%
metadata-eval63.6%
*-lft-identity63.6%
+-commutative63.6%
mul-1-neg63.6%
unsub-neg63.6%
*-commutative63.6%
Simplified63.6%
if -4.4000000000000003e29 < c < -5.60000000000000023e-141Initial program 70.9%
+-commutative70.9%
fma-def74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 80.9%
+-commutative80.9%
associate--l+80.9%
sub-neg80.9%
sub-neg80.9%
associate-*r*80.9%
associate-*r*80.9%
distribute-lft-out--84.1%
associate-*r*84.1%
+-commutative84.1%
*-commutative84.1%
associate-*l*84.1%
*-commutative84.1%
distribute-lft-out--84.1%
Simplified87.4%
Taylor expanded in x around inf 58.8%
+-commutative58.8%
mul-1-neg58.8%
unsub-neg58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in z around inf 52.7%
if -5.60000000000000023e-141 < c < 9.9999999999999996e-82Initial program 78.1%
Taylor expanded in a around inf 58.4%
associate-*r*58.4%
neg-mul-158.4%
cancel-sign-sub58.4%
+-commutative58.4%
mul-1-neg58.4%
unsub-neg58.4%
*-commutative58.4%
*-commutative58.4%
Simplified58.4%
if 9.9999999999999996e-82 < c < 6.29999999999999997e97Initial program 89.0%
Taylor expanded in t around inf 56.6%
+-commutative56.6%
mul-1-neg56.6%
unsub-neg56.6%
*-commutative56.6%
*-commutative56.6%
Simplified56.6%
Final simplification66.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* z (- c)))))
(if (<= c -1.42e+155)
(* j (* t c))
(if (<= c -1.05e+41)
t_1
(if (<= c -2.4e+35)
(* (* x t) (- a))
(if (<= c -5e-213)
(* x (* y z))
(if (<= c 1.5e-85)
(* b (* a i))
(if (<= c 8e+29)
(* i (* y (- j)))
(if (<= c 1.5e+228) (* t (* c j)) t_1)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double tmp;
if (c <= -1.42e+155) {
tmp = j * (t * c);
} else if (c <= -1.05e+41) {
tmp = t_1;
} else if (c <= -2.4e+35) {
tmp = (x * t) * -a;
} else if (c <= -5e-213) {
tmp = x * (y * z);
} else if (c <= 1.5e-85) {
tmp = b * (a * i);
} else if (c <= 8e+29) {
tmp = i * (y * -j);
} else if (c <= 1.5e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * (z * -c)
if (c <= (-1.42d+155)) then
tmp = j * (t * c)
else if (c <= (-1.05d+41)) then
tmp = t_1
else if (c <= (-2.4d+35)) then
tmp = (x * t) * -a
else if (c <= (-5d-213)) then
tmp = x * (y * z)
else if (c <= 1.5d-85) then
tmp = b * (a * i)
else if (c <= 8d+29) then
tmp = i * (y * -j)
else if (c <= 1.5d+228) then
tmp = t * (c * j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double tmp;
if (c <= -1.42e+155) {
tmp = j * (t * c);
} else if (c <= -1.05e+41) {
tmp = t_1;
} else if (c <= -2.4e+35) {
tmp = (x * t) * -a;
} else if (c <= -5e-213) {
tmp = x * (y * z);
} else if (c <= 1.5e-85) {
tmp = b * (a * i);
} else if (c <= 8e+29) {
tmp = i * (y * -j);
} else if (c <= 1.5e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (z * -c) tmp = 0 if c <= -1.42e+155: tmp = j * (t * c) elif c <= -1.05e+41: tmp = t_1 elif c <= -2.4e+35: tmp = (x * t) * -a elif c <= -5e-213: tmp = x * (y * z) elif c <= 1.5e-85: tmp = b * (a * i) elif c <= 8e+29: tmp = i * (y * -j) elif c <= 1.5e+228: tmp = t * (c * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(z * Float64(-c))) tmp = 0.0 if (c <= -1.42e+155) tmp = Float64(j * Float64(t * c)); elseif (c <= -1.05e+41) tmp = t_1; elseif (c <= -2.4e+35) tmp = Float64(Float64(x * t) * Float64(-a)); elseif (c <= -5e-213) tmp = Float64(x * Float64(y * z)); elseif (c <= 1.5e-85) tmp = Float64(b * Float64(a * i)); elseif (c <= 8e+29) tmp = Float64(i * Float64(y * Float64(-j))); elseif (c <= 1.5e+228) tmp = Float64(t * Float64(c * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (z * -c); tmp = 0.0; if (c <= -1.42e+155) tmp = j * (t * c); elseif (c <= -1.05e+41) tmp = t_1; elseif (c <= -2.4e+35) tmp = (x * t) * -a; elseif (c <= -5e-213) tmp = x * (y * z); elseif (c <= 1.5e-85) tmp = b * (a * i); elseif (c <= 8e+29) tmp = i * (y * -j); elseif (c <= 1.5e+228) tmp = t * (c * j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.42e+155], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.05e+41], t$95$1, If[LessEqual[c, -2.4e+35], N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision], If[LessEqual[c, -5e-213], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.5e-85], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 8e+29], N[(i * N[(y * (-j)), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.5e+228], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(z \cdot \left(-c\right)\right)\\
\mathbf{if}\;c \leq -1.42 \cdot 10^{+155}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq -1.05 \cdot 10^{+41}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -2.4 \cdot 10^{+35}:\\
\;\;\;\;\left(x \cdot t\right) \cdot \left(-a\right)\\
\mathbf{elif}\;c \leq -5 \cdot 10^{-213}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 1.5 \cdot 10^{-85}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;c \leq 8 \cdot 10^{+29}:\\
\;\;\;\;i \cdot \left(y \cdot \left(-j\right)\right)\\
\mathbf{elif}\;c \leq 1.5 \cdot 10^{+228}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -1.41999999999999994e155Initial program 42.2%
Taylor expanded in c around inf 73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in t around inf 45.7%
*-commutative45.7%
*-commutative45.7%
*-commutative45.7%
associate-*r*52.2%
Simplified52.2%
if -1.41999999999999994e155 < c < -1.05e41 or 1.5000000000000001e228 < c Initial program 71.3%
Taylor expanded in y around 0 76.3%
*-commutative76.3%
*-commutative76.3%
*-commutative76.3%
*-rgt-identity76.3%
cancel-sign-sub-inv76.3%
Simplified74.2%
Taylor expanded in j around inf 76.3%
Taylor expanded in z around inf 54.7%
mul-1-neg54.7%
*-commutative54.7%
Simplified54.7%
if -1.05e41 < c < -2.40000000000000015e35Initial program 100.0%
Taylor expanded in a around inf 100.0%
associate-*r*100.0%
neg-mul-1100.0%
cancel-sign-sub100.0%
+-commutative100.0%
mul-1-neg100.0%
unsub-neg100.0%
*-commutative100.0%
*-commutative100.0%
Simplified100.0%
Taylor expanded in i around 0 100.0%
neg-mul-1100.0%
distribute-rgt-neg-in100.0%
Simplified100.0%
if -2.40000000000000015e35 < c < -4.99999999999999977e-213Initial program 75.5%
+-commutative75.5%
fma-def77.7%
*-commutative77.7%
*-commutative77.7%
cancel-sign-sub-inv77.7%
cancel-sign-sub77.7%
remove-double-neg77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Taylor expanded in z around 0 82.4%
+-commutative82.4%
associate--l+82.4%
sub-neg82.4%
sub-neg82.4%
associate-*r*82.4%
associate-*r*82.4%
distribute-lft-out--84.6%
associate-*r*84.6%
+-commutative84.6%
*-commutative84.6%
associate-*l*84.6%
*-commutative84.6%
distribute-lft-out--84.6%
Simplified86.9%
Taylor expanded in x around inf 60.8%
+-commutative60.8%
mul-1-neg60.8%
unsub-neg60.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in z around inf 47.7%
if -4.99999999999999977e-213 < c < 1.50000000000000011e-85Initial program 77.7%
Taylor expanded in y around 0 60.8%
*-commutative60.8%
*-commutative60.8%
*-commutative60.8%
*-rgt-identity60.8%
cancel-sign-sub-inv60.8%
Simplified62.5%
Taylor expanded in j around inf 42.1%
Taylor expanded in c around 0 35.9%
associate-*r*34.5%
*-commutative34.5%
associate-*l*38.9%
Simplified38.9%
if 1.50000000000000011e-85 < c < 7.99999999999999931e29Initial program 80.6%
Taylor expanded in j around inf 44.4%
Taylor expanded in c around 0 35.8%
mul-1-neg35.8%
*-commutative35.8%
distribute-rgt-neg-in35.8%
*-commutative35.8%
Simplified35.8%
if 7.99999999999999931e29 < c < 1.5000000000000001e228Initial program 75.4%
Taylor expanded in j around inf 48.4%
Taylor expanded in c around inf 42.7%
*-commutative42.7%
*-commutative42.7%
associate-*r*45.8%
Simplified45.8%
Final simplification46.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -1.6e+116)
t_1
(if (<= x 8.5e-263)
(* c (- (* t j) (* z b)))
(if (<= x 9.4e+33)
(* i (- (* a b) (* y j)))
(if (or (<= x 2.4e+207) (not (<= x 1.6e+251)))
t_1
(* z (- (* x y) (* b c)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.6e+116) {
tmp = t_1;
} else if (x <= 8.5e-263) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 9.4e+33) {
tmp = i * ((a * b) - (y * j));
} else if ((x <= 2.4e+207) || !(x <= 1.6e+251)) {
tmp = t_1;
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if (x <= (-1.6d+116)) then
tmp = t_1
else if (x <= 8.5d-263) then
tmp = c * ((t * j) - (z * b))
else if (x <= 9.4d+33) then
tmp = i * ((a * b) - (y * j))
else if ((x <= 2.4d+207) .or. (.not. (x <= 1.6d+251))) then
tmp = t_1
else
tmp = z * ((x * y) - (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.6e+116) {
tmp = t_1;
} else if (x <= 8.5e-263) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 9.4e+33) {
tmp = i * ((a * b) - (y * j));
} else if ((x <= 2.4e+207) || !(x <= 1.6e+251)) {
tmp = t_1;
} else {
tmp = z * ((x * y) - (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if x <= -1.6e+116: tmp = t_1 elif x <= 8.5e-263: tmp = c * ((t * j) - (z * b)) elif x <= 9.4e+33: tmp = i * ((a * b) - (y * j)) elif (x <= 2.4e+207) or not (x <= 1.6e+251): tmp = t_1 else: tmp = z * ((x * y) - (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -1.6e+116) tmp = t_1; elseif (x <= 8.5e-263) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (x <= 9.4e+33) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif ((x <= 2.4e+207) || !(x <= 1.6e+251)) tmp = t_1; else tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -1.6e+116) tmp = t_1; elseif (x <= 8.5e-263) tmp = c * ((t * j) - (z * b)); elseif (x <= 9.4e+33) tmp = i * ((a * b) - (y * j)); elseif ((x <= 2.4e+207) || ~((x <= 1.6e+251))) tmp = t_1; else tmp = z * ((x * y) - (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.6e+116], t$95$1, If[LessEqual[x, 8.5e-263], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.4e+33], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[x, 2.4e+207], N[Not[LessEqual[x, 1.6e+251]], $MachinePrecision]], t$95$1, N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+116}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 8.5 \cdot 10^{-263}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;x \leq 9.4 \cdot 10^{+33}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{+207} \lor \neg \left(x \leq 1.6 \cdot 10^{+251}\right):\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\end{array}
\end{array}
if x < -1.6e116 or 9.3999999999999996e33 < x < 2.4000000000000001e207 or 1.5999999999999999e251 < x Initial program 82.0%
+-commutative82.0%
fma-def83.2%
*-commutative83.2%
*-commutative83.2%
cancel-sign-sub-inv83.2%
cancel-sign-sub83.2%
remove-double-neg83.2%
*-commutative83.2%
*-commutative83.2%
Simplified83.2%
Taylor expanded in z around 0 72.3%
+-commutative72.3%
associate--l+72.3%
sub-neg72.3%
sub-neg72.3%
associate-*r*72.3%
associate-*r*72.3%
distribute-lft-out--72.3%
associate-*r*72.3%
+-commutative72.3%
*-commutative72.3%
associate-*l*72.3%
*-commutative72.3%
distribute-lft-out--72.3%
Simplified73.6%
Taylor expanded in x around inf 73.8%
+-commutative73.8%
mul-1-neg73.8%
unsub-neg73.8%
*-commutative73.8%
Simplified73.8%
if -1.6e116 < x < 8.49999999999999975e-263Initial program 70.8%
Taylor expanded in c around inf 63.7%
*-commutative63.7%
*-commutative63.7%
Simplified63.7%
if 8.49999999999999975e-263 < x < 9.3999999999999996e33Initial program 68.1%
Taylor expanded in i around inf 58.7%
cancel-sign-sub-inv58.7%
metadata-eval58.7%
*-lft-identity58.7%
+-commutative58.7%
mul-1-neg58.7%
unsub-neg58.7%
*-commutative58.7%
Simplified58.7%
if 2.4000000000000001e207 < x < 1.5999999999999999e251Initial program 36.2%
Taylor expanded in z around inf 74.1%
*-commutative74.1%
Simplified74.1%
Final simplification66.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -3.2e+131)
t_1
(if (<= c -8.6e+70)
(* i (- (* a b) (* y j)))
(if (<= c -6.8e+29)
t_1
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 15000000000000.0) (* a (- (* b i) (* x t))) 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 <= -3.2e+131) {
tmp = t_1;
} else if (c <= -8.6e+70) {
tmp = i * ((a * b) - (y * j));
} else if (c <= -6.8e+29) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 15000000000000.0) {
tmp = a * ((b * i) - (x * t));
} 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 <= (-3.2d+131)) then
tmp = t_1
else if (c <= (-8.6d+70)) then
tmp = i * ((a * b) - (y * j))
else if (c <= (-6.8d+29)) then
tmp = t_1
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 15000000000000.0d0) then
tmp = a * ((b * i) - (x * t))
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 <= -3.2e+131) {
tmp = t_1;
} else if (c <= -8.6e+70) {
tmp = i * ((a * b) - (y * j));
} else if (c <= -6.8e+29) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 15000000000000.0) {
tmp = a * ((b * i) - (x * t));
} 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 <= -3.2e+131: tmp = t_1 elif c <= -8.6e+70: tmp = i * ((a * b) - (y * j)) elif c <= -6.8e+29: tmp = t_1 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 15000000000000.0: tmp = a * ((b * i) - (x * t)) 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 <= -3.2e+131) tmp = t_1; elseif (c <= -8.6e+70) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (c <= -6.8e+29) tmp = t_1; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 15000000000000.0) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); 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 <= -3.2e+131) tmp = t_1; elseif (c <= -8.6e+70) tmp = i * ((a * b) - (y * j)); elseif (c <= -6.8e+29) tmp = t_1; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 15000000000000.0) tmp = a * ((b * i) - (x * t)); 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, -3.2e+131], t$95$1, If[LessEqual[c, -8.6e+70], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -6.8e+29], t$95$1, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 15000000000000.0], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -3.2 \cdot 10^{+131}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -8.6 \cdot 10^{+70}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;c \leq -6.8 \cdot 10^{+29}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 15000000000000:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -3.2000000000000002e131 or -8.6000000000000002e70 < c < -6.79999999999999963e29 or 1.5e13 < c Initial program 68.5%
Taylor expanded in c around inf 75.8%
*-commutative75.8%
*-commutative75.8%
Simplified75.8%
if -3.2000000000000002e131 < c < -8.6000000000000002e70Initial program 59.8%
Taylor expanded in i around inf 56.3%
cancel-sign-sub-inv56.3%
metadata-eval56.3%
*-lft-identity56.3%
+-commutative56.3%
mul-1-neg56.3%
unsub-neg56.3%
*-commutative56.3%
Simplified56.3%
if -6.79999999999999963e29 < c < -5.60000000000000023e-141Initial program 70.9%
+-commutative70.9%
fma-def74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 80.9%
+-commutative80.9%
associate--l+80.9%
sub-neg80.9%
sub-neg80.9%
associate-*r*80.9%
associate-*r*80.9%
distribute-lft-out--84.1%
associate-*r*84.1%
+-commutative84.1%
*-commutative84.1%
associate-*l*84.1%
*-commutative84.1%
distribute-lft-out--84.1%
Simplified87.4%
Taylor expanded in x around inf 58.8%
+-commutative58.8%
mul-1-neg58.8%
unsub-neg58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in z around inf 52.7%
if -5.60000000000000023e-141 < c < 1.5e13Initial program 78.8%
Taylor expanded in a around inf 54.8%
associate-*r*54.8%
neg-mul-154.8%
cancel-sign-sub54.8%
+-commutative54.8%
mul-1-neg54.8%
unsub-neg54.8%
*-commutative54.8%
*-commutative54.8%
Simplified54.8%
Final simplification64.1%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= y -5e+100) (not (<= y 2.6e+119))) (* y (- (* x z) (* i j))) (+ (* t (* c j)) (* b (- (* a i) (* z c))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((y <= -5e+100) || !(y <= 2.6e+119)) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((y <= (-5d+100)) .or. (.not. (y <= 2.6d+119))) then
tmp = y * ((x * z) - (i * j))
else
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((y <= -5e+100) || !(y <= 2.6e+119)) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = (t * (c * j)) + (b * ((a * i) - (z * c)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (y <= -5e+100) or not (y <= 2.6e+119): tmp = y * ((x * z) - (i * j)) else: tmp = (t * (c * j)) + (b * ((a * i) - (z * c))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((y <= -5e+100) || !(y <= 2.6e+119)) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); else tmp = Float64(Float64(t * Float64(c * j)) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((y <= -5e+100) || ~((y <= 2.6e+119))) tmp = y * ((x * z) - (i * j)); else tmp = (t * (c * j)) + (b * ((a * i) - (z * c))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[y, -5e+100], N[Not[LessEqual[y, 2.6e+119]], $MachinePrecision]], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5 \cdot 10^{+100} \lor \neg \left(y \leq 2.6 \cdot 10^{+119}\right):\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\end{array}
\end{array}
if y < -4.9999999999999999e100 or 2.6e119 < y Initial program 62.9%
+-commutative62.9%
fma-def64.1%
*-commutative64.1%
*-commutative64.1%
cancel-sign-sub-inv64.1%
cancel-sign-sub64.1%
remove-double-neg64.1%
*-commutative64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in z around 0 65.6%
+-commutative65.6%
associate--l+65.6%
sub-neg65.6%
sub-neg65.6%
associate-*r*65.6%
associate-*r*65.6%
distribute-lft-out--66.7%
associate-*r*66.7%
+-commutative66.7%
*-commutative66.7%
associate-*l*66.7%
*-commutative66.7%
distribute-lft-out--66.7%
Simplified67.8%
Taylor expanded in y around inf 71.5%
+-commutative71.5%
mul-1-neg71.5%
unsub-neg71.5%
Simplified71.5%
if -4.9999999999999999e100 < y < 2.6e119Initial program 76.9%
Taylor expanded in y around 0 72.2%
*-commutative72.2%
*-commutative72.2%
*-commutative72.2%
*-rgt-identity72.2%
cancel-sign-sub-inv72.2%
Simplified73.8%
Taylor expanded in j around inf 64.0%
Final simplification66.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* z (- c)))) (t_2 (* j (* t c))))
(if (<= c -3.1e+155)
t_2
(if (<= c -3.2e+51)
t_1
(if (<= c -5.4e+32)
t_2
(if (<= c -3.5e-213)
(* x (* y z))
(if (<= c 4.9e-85)
(* b (* a i))
(if (<= c 2.5e+228) (* t (* c j)) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = j * (t * c);
double tmp;
if (c <= -3.1e+155) {
tmp = t_2;
} else if (c <= -3.2e+51) {
tmp = t_1;
} else if (c <= -5.4e+32) {
tmp = t_2;
} else if (c <= -3.5e-213) {
tmp = x * (y * z);
} else if (c <= 4.9e-85) {
tmp = b * (a * i);
} else if (c <= 2.5e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = b * (z * -c)
t_2 = j * (t * c)
if (c <= (-3.1d+155)) then
tmp = t_2
else if (c <= (-3.2d+51)) then
tmp = t_1
else if (c <= (-5.4d+32)) then
tmp = t_2
else if (c <= (-3.5d-213)) then
tmp = x * (y * z)
else if (c <= 4.9d-85) then
tmp = b * (a * i)
else if (c <= 2.5d+228) then
tmp = t * (c * j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = j * (t * c);
double tmp;
if (c <= -3.1e+155) {
tmp = t_2;
} else if (c <= -3.2e+51) {
tmp = t_1;
} else if (c <= -5.4e+32) {
tmp = t_2;
} else if (c <= -3.5e-213) {
tmp = x * (y * z);
} else if (c <= 4.9e-85) {
tmp = b * (a * i);
} else if (c <= 2.5e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (z * -c) t_2 = j * (t * c) tmp = 0 if c <= -3.1e+155: tmp = t_2 elif c <= -3.2e+51: tmp = t_1 elif c <= -5.4e+32: tmp = t_2 elif c <= -3.5e-213: tmp = x * (y * z) elif c <= 4.9e-85: tmp = b * (a * i) elif c <= 2.5e+228: tmp = t * (c * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(z * Float64(-c))) t_2 = Float64(j * Float64(t * c)) tmp = 0.0 if (c <= -3.1e+155) tmp = t_2; elseif (c <= -3.2e+51) tmp = t_1; elseif (c <= -5.4e+32) tmp = t_2; elseif (c <= -3.5e-213) tmp = Float64(x * Float64(y * z)); elseif (c <= 4.9e-85) tmp = Float64(b * Float64(a * i)); elseif (c <= 2.5e+228) tmp = Float64(t * Float64(c * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (z * -c); t_2 = j * (t * c); tmp = 0.0; if (c <= -3.1e+155) tmp = t_2; elseif (c <= -3.2e+51) tmp = t_1; elseif (c <= -5.4e+32) tmp = t_2; elseif (c <= -3.5e-213) tmp = x * (y * z); elseif (c <= 4.9e-85) tmp = b * (a * i); elseif (c <= 2.5e+228) tmp = t * (c * j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -3.1e+155], t$95$2, If[LessEqual[c, -3.2e+51], t$95$1, If[LessEqual[c, -5.4e+32], t$95$2, If[LessEqual[c, -3.5e-213], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4.9e-85], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 2.5e+228], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(z \cdot \left(-c\right)\right)\\
t_2 := j \cdot \left(t \cdot c\right)\\
\mathbf{if}\;c \leq -3.1 \cdot 10^{+155}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -3.2 \cdot 10^{+51}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -5.4 \cdot 10^{+32}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -3.5 \cdot 10^{-213}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 4.9 \cdot 10^{-85}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;c \leq 2.5 \cdot 10^{+228}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -3.09999999999999989e155 or -3.2000000000000002e51 < c < -5.40000000000000025e32Initial program 43.2%
Taylor expanded in c around inf 73.5%
*-commutative73.5%
*-commutative73.5%
Simplified73.5%
Taylor expanded in t around inf 46.3%
*-commutative46.3%
*-commutative46.3%
*-commutative46.3%
associate-*r*52.1%
Simplified52.1%
if -3.09999999999999989e155 < c < -3.2000000000000002e51 or 2.5e228 < c Initial program 74.4%
Taylor expanded in y around 0 77.4%
*-commutative77.4%
*-commutative77.4%
*-commutative77.4%
*-rgt-identity77.4%
cancel-sign-sub-inv77.4%
Simplified73.1%
Taylor expanded in j around inf 75.3%
Taylor expanded in z around inf 54.9%
mul-1-neg54.9%
*-commutative54.9%
Simplified54.9%
if -5.40000000000000025e32 < c < -3.50000000000000017e-213Initial program 75.5%
+-commutative75.5%
fma-def77.7%
*-commutative77.7%
*-commutative77.7%
cancel-sign-sub-inv77.7%
cancel-sign-sub77.7%
remove-double-neg77.7%
*-commutative77.7%
*-commutative77.7%
Simplified77.7%
Taylor expanded in z around 0 82.4%
+-commutative82.4%
associate--l+82.4%
sub-neg82.4%
sub-neg82.4%
associate-*r*82.4%
associate-*r*82.4%
distribute-lft-out--84.6%
associate-*r*84.6%
+-commutative84.6%
*-commutative84.6%
associate-*l*84.6%
*-commutative84.6%
distribute-lft-out--84.6%
Simplified86.9%
Taylor expanded in x around inf 60.8%
+-commutative60.8%
mul-1-neg60.8%
unsub-neg60.8%
*-commutative60.8%
Simplified60.8%
Taylor expanded in z around inf 47.7%
if -3.50000000000000017e-213 < c < 4.90000000000000015e-85Initial program 77.7%
Taylor expanded in y around 0 60.8%
*-commutative60.8%
*-commutative60.8%
*-commutative60.8%
*-rgt-identity60.8%
cancel-sign-sub-inv60.8%
Simplified62.5%
Taylor expanded in j around inf 42.1%
Taylor expanded in c around 0 35.9%
associate-*r*34.5%
*-commutative34.5%
associate-*l*38.9%
Simplified38.9%
if 4.90000000000000015e-85 < c < 2.5e228Initial program 77.0%
Taylor expanded in j around inf 47.2%
Taylor expanded in c around inf 34.0%
*-commutative34.0%
*-commutative34.0%
associate-*r*36.2%
Simplified36.2%
Final simplification44.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* z (- c)))) (t_2 (* (* x t) (- a))))
(if (<= c -1.52e+156)
(* j (* t c))
(if (<= c -4e+40)
t_1
(if (<= c -4.8e+37)
t_2
(if (<= c -3.3e-174)
(* x (* y z))
(if (<= c 29000000000000.0)
t_2
(if (<= c 1.55e+228) (* t (* c j)) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = (x * t) * -a;
double tmp;
if (c <= -1.52e+156) {
tmp = j * (t * c);
} else if (c <= -4e+40) {
tmp = t_1;
} else if (c <= -4.8e+37) {
tmp = t_2;
} else if (c <= -3.3e-174) {
tmp = x * (y * z);
} else if (c <= 29000000000000.0) {
tmp = t_2;
} else if (c <= 1.55e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = b * (z * -c)
t_2 = (x * t) * -a
if (c <= (-1.52d+156)) then
tmp = j * (t * c)
else if (c <= (-4d+40)) then
tmp = t_1
else if (c <= (-4.8d+37)) then
tmp = t_2
else if (c <= (-3.3d-174)) then
tmp = x * (y * z)
else if (c <= 29000000000000.0d0) then
tmp = t_2
else if (c <= 1.55d+228) then
tmp = t * (c * j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = (x * t) * -a;
double tmp;
if (c <= -1.52e+156) {
tmp = j * (t * c);
} else if (c <= -4e+40) {
tmp = t_1;
} else if (c <= -4.8e+37) {
tmp = t_2;
} else if (c <= -3.3e-174) {
tmp = x * (y * z);
} else if (c <= 29000000000000.0) {
tmp = t_2;
} else if (c <= 1.55e+228) {
tmp = t * (c * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (z * -c) t_2 = (x * t) * -a tmp = 0 if c <= -1.52e+156: tmp = j * (t * c) elif c <= -4e+40: tmp = t_1 elif c <= -4.8e+37: tmp = t_2 elif c <= -3.3e-174: tmp = x * (y * z) elif c <= 29000000000000.0: tmp = t_2 elif c <= 1.55e+228: tmp = t * (c * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(z * Float64(-c))) t_2 = Float64(Float64(x * t) * Float64(-a)) tmp = 0.0 if (c <= -1.52e+156) tmp = Float64(j * Float64(t * c)); elseif (c <= -4e+40) tmp = t_1; elseif (c <= -4.8e+37) tmp = t_2; elseif (c <= -3.3e-174) tmp = Float64(x * Float64(y * z)); elseif (c <= 29000000000000.0) tmp = t_2; elseif (c <= 1.55e+228) tmp = Float64(t * Float64(c * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (z * -c); t_2 = (x * t) * -a; tmp = 0.0; if (c <= -1.52e+156) tmp = j * (t * c); elseif (c <= -4e+40) tmp = t_1; elseif (c <= -4.8e+37) tmp = t_2; elseif (c <= -3.3e-174) tmp = x * (y * z); elseif (c <= 29000000000000.0) tmp = t_2; elseif (c <= 1.55e+228) tmp = t * (c * j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * t), $MachinePrecision] * (-a)), $MachinePrecision]}, If[LessEqual[c, -1.52e+156], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -4e+40], t$95$1, If[LessEqual[c, -4.8e+37], t$95$2, If[LessEqual[c, -3.3e-174], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 29000000000000.0], t$95$2, If[LessEqual[c, 1.55e+228], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(z \cdot \left(-c\right)\right)\\
t_2 := \left(x \cdot t\right) \cdot \left(-a\right)\\
\mathbf{if}\;c \leq -1.52 \cdot 10^{+156}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq -4 \cdot 10^{+40}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -4.8 \cdot 10^{+37}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq -3.3 \cdot 10^{-174}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 29000000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;c \leq 1.55 \cdot 10^{+228}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -1.52e156Initial program 42.2%
Taylor expanded in c around inf 73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in t around inf 45.7%
*-commutative45.7%
*-commutative45.7%
*-commutative45.7%
associate-*r*52.2%
Simplified52.2%
if -1.52e156 < c < -4.00000000000000012e40 or 1.5499999999999999e228 < c Initial program 71.3%
Taylor expanded in y around 0 76.3%
*-commutative76.3%
*-commutative76.3%
*-commutative76.3%
*-rgt-identity76.3%
cancel-sign-sub-inv76.3%
Simplified74.2%
Taylor expanded in j around inf 76.3%
Taylor expanded in z around inf 54.7%
mul-1-neg54.7%
*-commutative54.7%
Simplified54.7%
if -4.00000000000000012e40 < c < -4.8e37 or -3.3000000000000001e-174 < c < 2.9e13Initial program 79.2%
Taylor expanded in a around inf 55.4%
associate-*r*55.4%
neg-mul-155.4%
cancel-sign-sub55.4%
+-commutative55.4%
mul-1-neg55.4%
unsub-neg55.4%
*-commutative55.4%
*-commutative55.4%
Simplified55.4%
Taylor expanded in i around 0 34.8%
neg-mul-134.8%
distribute-rgt-neg-in34.8%
Simplified34.8%
if -4.8e37 < c < -3.3000000000000001e-174Initial program 72.8%
+-commutative72.8%
fma-def75.5%
*-commutative75.5%
*-commutative75.5%
cancel-sign-sub-inv75.5%
cancel-sign-sub75.5%
remove-double-neg75.5%
*-commutative75.5%
*-commutative75.5%
Simplified75.5%
Taylor expanded in z around 0 81.2%
+-commutative81.2%
associate--l+81.2%
sub-neg81.2%
sub-neg81.2%
associate-*r*81.2%
associate-*r*81.2%
distribute-lft-out--83.9%
associate-*r*83.9%
+-commutative83.9%
*-commutative83.9%
associate-*l*83.9%
*-commutative83.9%
distribute-lft-out--83.9%
Simplified86.7%
Taylor expanded in x around inf 60.1%
+-commutative60.1%
mul-1-neg60.1%
unsub-neg60.1%
*-commutative60.1%
Simplified60.1%
Taylor expanded in z around inf 52.3%
if 2.9e13 < c < 1.5499999999999999e228Initial program 76.4%
Taylor expanded in j around inf 48.6%
Taylor expanded in c around inf 41.1%
*-commutative41.1%
*-commutative41.1%
associate-*r*44.1%
Simplified44.1%
Final simplification44.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (- (* b i) (* x t)))))
(if (<= c -7e+134)
(* j (* t c))
(if (<= c -9.5e+37)
t_1
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 3.3e+128)
t_1
(if (<= c 5.5e+227) (* t (* c j)) (* b (* z (- c))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double tmp;
if (c <= -7e+134) {
tmp = j * (t * c);
} else if (c <= -9.5e+37) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 3.3e+128) {
tmp = t_1;
} else if (c <= 5.5e+227) {
tmp = t * (c * j);
} else {
tmp = b * (z * -c);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = a * ((b * i) - (x * t))
if (c <= (-7d+134)) then
tmp = j * (t * c)
else if (c <= (-9.5d+37)) then
tmp = t_1
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 3.3d+128) then
tmp = t_1
else if (c <= 5.5d+227) then
tmp = t * (c * j)
else
tmp = b * (z * -c)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * ((b * i) - (x * t));
double tmp;
if (c <= -7e+134) {
tmp = j * (t * c);
} else if (c <= -9.5e+37) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 3.3e+128) {
tmp = t_1;
} else if (c <= 5.5e+227) {
tmp = t * (c * j);
} else {
tmp = b * (z * -c);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * ((b * i) - (x * t)) tmp = 0 if c <= -7e+134: tmp = j * (t * c) elif c <= -9.5e+37: tmp = t_1 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 3.3e+128: tmp = t_1 elif c <= 5.5e+227: tmp = t * (c * j) else: tmp = b * (z * -c) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(Float64(b * i) - Float64(x * t))) tmp = 0.0 if (c <= -7e+134) tmp = Float64(j * Float64(t * c)); elseif (c <= -9.5e+37) tmp = t_1; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 3.3e+128) tmp = t_1; elseif (c <= 5.5e+227) tmp = Float64(t * Float64(c * j)); else tmp = Float64(b * Float64(z * Float64(-c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * ((b * i) - (x * t)); tmp = 0.0; if (c <= -7e+134) tmp = j * (t * c); elseif (c <= -9.5e+37) tmp = t_1; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 3.3e+128) tmp = t_1; elseif (c <= 5.5e+227) tmp = t * (c * j); else tmp = b * (z * -c); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -7e+134], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -9.5e+37], t$95$1, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 3.3e+128], t$95$1, If[LessEqual[c, 5.5e+227], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{if}\;c \leq -7 \cdot 10^{+134}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq -9.5 \cdot 10^{+37}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 3.3 \cdot 10^{+128}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq 5.5 \cdot 10^{+227}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(z \cdot \left(-c\right)\right)\\
\end{array}
\end{array}
if c < -7.00000000000000006e134Initial program 47.7%
Taylor expanded in c around inf 77.2%
*-commutative77.2%
*-commutative77.2%
Simplified77.2%
Taylor expanded in t around inf 45.2%
*-commutative45.2%
*-commutative45.2%
*-commutative45.2%
associate-*r*50.7%
Simplified50.7%
if -7.00000000000000006e134 < c < -9.4999999999999995e37 or -5.60000000000000023e-141 < c < 3.3000000000000001e128Initial program 77.7%
Taylor expanded in a around inf 51.6%
associate-*r*51.6%
neg-mul-151.6%
cancel-sign-sub51.6%
+-commutative51.6%
mul-1-neg51.6%
unsub-neg51.6%
*-commutative51.6%
*-commutative51.6%
Simplified51.6%
if -9.4999999999999995e37 < c < -5.60000000000000023e-141Initial program 71.8%
+-commutative71.8%
fma-def74.9%
*-commutative74.9%
*-commutative74.9%
cancel-sign-sub-inv74.9%
cancel-sign-sub74.9%
remove-double-neg74.9%
*-commutative74.9%
*-commutative74.9%
Simplified74.9%
Taylor expanded in z around 0 81.5%
+-commutative81.5%
associate--l+81.5%
sub-neg81.5%
sub-neg81.5%
associate-*r*81.5%
associate-*r*81.5%
distribute-lft-out--84.6%
associate-*r*84.6%
+-commutative84.6%
*-commutative84.6%
associate-*l*84.6%
*-commutative84.6%
distribute-lft-out--84.6%
Simplified87.8%
Taylor expanded in x around inf 57.1%
+-commutative57.1%
mul-1-neg57.1%
unsub-neg57.1%
*-commutative57.1%
Simplified57.1%
Taylor expanded in z around inf 51.1%
if 3.3000000000000001e128 < c < 5.5000000000000001e227Initial program 68.4%
Taylor expanded in j around inf 45.1%
Taylor expanded in c around inf 46.0%
*-commutative46.0%
*-commutative46.0%
associate-*r*47.7%
Simplified47.7%
if 5.5000000000000001e227 < c Initial program 80.0%
Taylor expanded in y around 0 88.0%
*-commutative88.0%
*-commutative88.0%
*-commutative88.0%
*-rgt-identity88.0%
cancel-sign-sub-inv88.0%
Simplified84.0%
Taylor expanded in j around inf 84.0%
Taylor expanded in z around inf 69.3%
mul-1-neg69.3%
*-commutative69.3%
Simplified69.3%
Final simplification52.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= c -9.5e+156)
(* j (* t c))
(if (<= c -1.3e+30)
t_1
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 1.75e+126) (* a (- (* b i) (* x t))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (c <= -9.5e+156) {
tmp = j * (t * c);
} else if (c <= -1.3e+30) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 1.75e+126) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (c <= (-9.5d+156)) then
tmp = j * (t * c)
else if (c <= (-1.3d+30)) then
tmp = t_1
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 1.75d+126) then
tmp = a * ((b * i) - (x * t))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (c <= -9.5e+156) {
tmp = j * (t * c);
} else if (c <= -1.3e+30) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 1.75e+126) {
tmp = a * ((b * i) - (x * t));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if c <= -9.5e+156: tmp = j * (t * c) elif c <= -1.3e+30: tmp = t_1 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 1.75e+126: tmp = a * ((b * i) - (x * t)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (c <= -9.5e+156) tmp = Float64(j * Float64(t * c)); elseif (c <= -1.3e+30) tmp = t_1; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 1.75e+126) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (c <= -9.5e+156) tmp = j * (t * c); elseif (c <= -1.3e+30) tmp = t_1; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 1.75e+126) tmp = a * ((b * i) - (x * t)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -9.5e+156], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -1.3e+30], t$95$1, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 1.75e+126], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;c \leq -9.5 \cdot 10^{+156}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq -1.3 \cdot 10^{+30}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 1.75 \cdot 10^{+126}:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -9.5000000000000002e156Initial program 42.2%
Taylor expanded in c around inf 73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in t around inf 45.7%
*-commutative45.7%
*-commutative45.7%
*-commutative45.7%
associate-*r*52.2%
Simplified52.2%
if -9.5000000000000002e156 < c < -1.29999999999999994e30 or 1.7500000000000001e126 < c Initial program 71.3%
Taylor expanded in b around inf 55.9%
*-commutative55.9%
Simplified55.9%
if -1.29999999999999994e30 < c < -5.60000000000000023e-141Initial program 70.9%
+-commutative70.9%
fma-def74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 80.9%
+-commutative80.9%
associate--l+80.9%
sub-neg80.9%
sub-neg80.9%
associate-*r*80.9%
associate-*r*80.9%
distribute-lft-out--84.1%
associate-*r*84.1%
+-commutative84.1%
*-commutative84.1%
associate-*l*84.1%
*-commutative84.1%
distribute-lft-out--84.1%
Simplified87.4%
Taylor expanded in x around inf 58.8%
+-commutative58.8%
mul-1-neg58.8%
unsub-neg58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in z around inf 52.7%
if -5.60000000000000023e-141 < c < 1.7500000000000001e126Initial program 80.6%
Taylor expanded in a around inf 52.9%
associate-*r*52.9%
neg-mul-152.9%
cancel-sign-sub52.9%
+-commutative52.9%
mul-1-neg52.9%
unsub-neg52.9%
*-commutative52.9%
*-commutative52.9%
Simplified52.9%
Final simplification53.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -2.05e+30)
t_1
(if (<= c -5.6e-141)
(* x (* y z))
(if (<= c 16000000000000.0) (* a (- (* b i) (* x t))) 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.05e+30) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 16000000000000.0) {
tmp = a * ((b * i) - (x * t));
} 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.05d+30)) then
tmp = t_1
else if (c <= (-5.6d-141)) then
tmp = x * (y * z)
else if (c <= 16000000000000.0d0) then
tmp = a * ((b * i) - (x * t))
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.05e+30) {
tmp = t_1;
} else if (c <= -5.6e-141) {
tmp = x * (y * z);
} else if (c <= 16000000000000.0) {
tmp = a * ((b * i) - (x * t));
} 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.05e+30: tmp = t_1 elif c <= -5.6e-141: tmp = x * (y * z) elif c <= 16000000000000.0: tmp = a * ((b * i) - (x * t)) 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.05e+30) tmp = t_1; elseif (c <= -5.6e-141) tmp = Float64(x * Float64(y * z)); elseif (c <= 16000000000000.0) tmp = Float64(a * Float64(Float64(b * i) - Float64(x * t))); 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.05e+30) tmp = t_1; elseif (c <= -5.6e-141) tmp = x * (y * z); elseif (c <= 16000000000000.0) tmp = a * ((b * i) - (x * t)); 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.05e+30], t$95$1, If[LessEqual[c, -5.6e-141], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 16000000000000.0], N[(a * N[(N[(b * i), $MachinePrecision] - N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -2.05 \cdot 10^{+30}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;c \leq -5.6 \cdot 10^{-141}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 16000000000000:\\
\;\;\;\;a \cdot \left(b \cdot i - x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if c < -2.05000000000000003e30 or 1.6e13 < c Initial program 67.5%
Taylor expanded in c around inf 70.3%
*-commutative70.3%
*-commutative70.3%
Simplified70.3%
if -2.05000000000000003e30 < c < -5.60000000000000023e-141Initial program 70.9%
+-commutative70.9%
fma-def74.1%
*-commutative74.1%
*-commutative74.1%
cancel-sign-sub-inv74.1%
cancel-sign-sub74.1%
remove-double-neg74.1%
*-commutative74.1%
*-commutative74.1%
Simplified74.1%
Taylor expanded in z around 0 80.9%
+-commutative80.9%
associate--l+80.9%
sub-neg80.9%
sub-neg80.9%
associate-*r*80.9%
associate-*r*80.9%
distribute-lft-out--84.1%
associate-*r*84.1%
+-commutative84.1%
*-commutative84.1%
associate-*l*84.1%
*-commutative84.1%
distribute-lft-out--84.1%
Simplified87.4%
Taylor expanded in x around inf 58.8%
+-commutative58.8%
mul-1-neg58.8%
unsub-neg58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in z around inf 52.7%
if -5.60000000000000023e-141 < c < 1.6e13Initial program 78.8%
Taylor expanded in a around inf 54.8%
associate-*r*54.8%
neg-mul-154.8%
cancel-sign-sub54.8%
+-commutative54.8%
mul-1-neg54.8%
unsub-neg54.8%
*-commutative54.8%
*-commutative54.8%
Simplified54.8%
Final simplification62.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -2.25e+116)
t_1
(if (<= x 2e-263)
(* c (- (* t j) (* z b)))
(if (<= x 4.5e+34) (* i (- (* a b) (* y j))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -2.25e+116) {
tmp = t_1;
} else if (x <= 2e-263) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 4.5e+34) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((y * z) - (t * a))
if (x <= (-2.25d+116)) then
tmp = t_1
else if (x <= 2d-263) then
tmp = c * ((t * j) - (z * b))
else if (x <= 4.5d+34) then
tmp = i * ((a * b) - (y * j))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -2.25e+116) {
tmp = t_1;
} else if (x <= 2e-263) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 4.5e+34) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * ((y * z) - (t * a)) tmp = 0 if x <= -2.25e+116: tmp = t_1 elif x <= 2e-263: tmp = c * ((t * j) - (z * b)) elif x <= 4.5e+34: tmp = i * ((a * b) - (y * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -2.25e+116) tmp = t_1; elseif (x <= 2e-263) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (x <= 4.5e+34) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * ((y * z) - (t * a)); tmp = 0.0; if (x <= -2.25e+116) tmp = t_1; elseif (x <= 2e-263) tmp = c * ((t * j) - (z * b)); elseif (x <= 4.5e+34) tmp = i * ((a * b) - (y * j)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -2.25e+116], t$95$1, If[LessEqual[x, 2e-263], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.5e+34], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -2.25 \cdot 10^{+116}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;x \leq 2 \cdot 10^{-263}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{+34}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t_1\\
\end{array}
\end{array}
if x < -2.25000000000000008e116 or 4.5e34 < x Initial program 76.3%
+-commutative76.3%
fma-def78.5%
*-commutative78.5%
*-commutative78.5%
cancel-sign-sub-inv78.5%
cancel-sign-sub78.5%
remove-double-neg78.5%
*-commutative78.5%
*-commutative78.5%
Simplified78.5%
Taylor expanded in z around 0 71.2%
+-commutative71.2%
associate--l+71.2%
sub-neg71.2%
sub-neg71.2%
associate-*r*71.2%
associate-*r*71.2%
distribute-lft-out--71.2%
associate-*r*71.2%
+-commutative71.2%
*-commutative71.2%
associate-*l*71.2%
*-commutative71.2%
distribute-lft-out--71.2%
Simplified72.4%
Taylor expanded in x around inf 69.3%
+-commutative69.3%
mul-1-neg69.3%
unsub-neg69.3%
*-commutative69.3%
Simplified69.3%
if -2.25000000000000008e116 < x < 2e-263Initial program 70.8%
Taylor expanded in c around inf 63.7%
*-commutative63.7%
*-commutative63.7%
Simplified63.7%
if 2e-263 < x < 4.5e34Initial program 68.1%
Taylor expanded in i around inf 58.7%
cancel-sign-sub-inv58.7%
metadata-eval58.7%
*-lft-identity58.7%
+-commutative58.7%
mul-1-neg58.7%
unsub-neg58.7%
*-commutative58.7%
Simplified58.7%
Final simplification64.4%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -1.05e+136)
(* j (* t c))
(if (<= c -3.6e-213)
(* x (* y z))
(if (<= c 4.6e-85) (* b (* a 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 <= -1.05e+136) {
tmp = j * (t * c);
} else if (c <= -3.6e-213) {
tmp = x * (y * z);
} else if (c <= 4.6e-85) {
tmp = b * (a * 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 <= (-1.05d+136)) then
tmp = j * (t * c)
else if (c <= (-3.6d-213)) then
tmp = x * (y * z)
else if (c <= 4.6d-85) then
tmp = b * (a * 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 <= -1.05e+136) {
tmp = j * (t * c);
} else if (c <= -3.6e-213) {
tmp = x * (y * z);
} else if (c <= 4.6e-85) {
tmp = b * (a * i);
} else {
tmp = t * (c * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if c <= -1.05e+136: tmp = j * (t * c) elif c <= -3.6e-213: tmp = x * (y * z) elif c <= 4.6e-85: tmp = b * (a * i) else: tmp = t * (c * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -1.05e+136) tmp = Float64(j * Float64(t * c)); elseif (c <= -3.6e-213) tmp = Float64(x * Float64(y * z)); elseif (c <= 4.6e-85) tmp = Float64(b * Float64(a * 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 <= -1.05e+136) tmp = j * (t * c); elseif (c <= -3.6e-213) tmp = x * (y * z); elseif (c <= 4.6e-85) tmp = b * (a * i); else tmp = t * (c * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -1.05e+136], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -3.6e-213], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4.6e-85], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -1.05 \cdot 10^{+136}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq -3.6 \cdot 10^{-213}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;c \leq 4.6 \cdot 10^{-85}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\end{array}
\end{array}
if c < -1.05e136Initial program 46.1%
Taylor expanded in c around inf 76.5%
*-commutative76.5%
*-commutative76.5%
Simplified76.5%
Taylor expanded in t around inf 46.5%
*-commutative46.5%
*-commutative46.5%
*-commutative46.5%
associate-*r*52.1%
Simplified52.1%
if -1.05e136 < c < -3.6000000000000001e-213Initial program 71.5%
+-commutative71.5%
fma-def73.0%
*-commutative73.0%
*-commutative73.0%
cancel-sign-sub-inv73.0%
cancel-sign-sub73.0%
remove-double-neg73.0%
*-commutative73.0%
*-commutative73.0%
Simplified73.0%
Taylor expanded in z around 0 79.3%
+-commutative79.3%
associate--l+79.3%
sub-neg79.3%
sub-neg79.3%
associate-*r*79.3%
associate-*r*79.3%
distribute-lft-out--80.8%
associate-*r*80.8%
+-commutative80.8%
*-commutative80.8%
associate-*l*80.8%
*-commutative80.8%
distribute-lft-out--80.8%
Simplified82.4%
Taylor expanded in x around inf 51.9%
+-commutative51.9%
mul-1-neg51.9%
unsub-neg51.9%
*-commutative51.9%
Simplified51.9%
Taylor expanded in z around inf 38.7%
if -3.6000000000000001e-213 < c < 4.6000000000000001e-85Initial program 77.7%
Taylor expanded in y around 0 60.8%
*-commutative60.8%
*-commutative60.8%
*-commutative60.8%
*-rgt-identity60.8%
cancel-sign-sub-inv60.8%
Simplified62.5%
Taylor expanded in j around inf 42.1%
Taylor expanded in c around 0 35.9%
associate-*r*34.5%
*-commutative34.5%
associate-*l*38.9%
Simplified38.9%
if 4.6000000000000001e-85 < c Initial program 77.8%
Taylor expanded in j around inf 48.6%
Taylor expanded in c around inf 35.9%
*-commutative35.9%
*-commutative35.9%
associate-*r*39.5%
Simplified39.5%
Final simplification40.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= c -1.55e+132) (* j (* t c)) (if (<= c 4.9e-85) (* b (* a 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 <= -1.55e+132) {
tmp = j * (t * c);
} else if (c <= 4.9e-85) {
tmp = b * (a * 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 <= (-1.55d+132)) then
tmp = j * (t * c)
else if (c <= 4.9d-85) then
tmp = b * (a * 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 <= -1.55e+132) {
tmp = j * (t * c);
} else if (c <= 4.9e-85) {
tmp = b * (a * i);
} else {
tmp = t * (c * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if c <= -1.55e+132: tmp = j * (t * c) elif c <= 4.9e-85: tmp = b * (a * i) else: tmp = t * (c * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -1.55e+132) tmp = Float64(j * Float64(t * c)); elseif (c <= 4.9e-85) tmp = Float64(b * Float64(a * 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 <= -1.55e+132) tmp = j * (t * c); elseif (c <= 4.9e-85) tmp = b * (a * i); else tmp = t * (c * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -1.55e+132], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4.9e-85], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -1.55 \cdot 10^{+132}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;c \leq 4.9 \cdot 10^{-85}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\end{array}
\end{array}
if c < -1.5499999999999999e132Initial program 47.7%
Taylor expanded in c around inf 77.2%
*-commutative77.2%
*-commutative77.2%
Simplified77.2%
Taylor expanded in t around inf 45.2%
*-commutative45.2%
*-commutative45.2%
*-commutative45.2%
associate-*r*50.7%
Simplified50.7%
if -1.5499999999999999e132 < c < 4.90000000000000015e-85Initial program 74.3%
Taylor expanded in y around 0 51.0%
*-commutative51.0%
*-commutative51.0%
*-commutative51.0%
*-rgt-identity51.0%
cancel-sign-sub-inv51.0%
Simplified55.0%
Taylor expanded in j around inf 39.2%
Taylor expanded in c around 0 26.1%
associate-*r*26.1%
*-commutative26.1%
associate-*l*27.5%
Simplified27.5%
if 4.90000000000000015e-85 < c Initial program 77.8%
Taylor expanded in j around inf 48.6%
Taylor expanded in c around inf 35.9%
*-commutative35.9%
*-commutative35.9%
associate-*r*39.5%
Simplified39.5%
Final simplification35.0%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= y -5.8e+31) (* a (* x t)) (* b (* a i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -5.8e+31) {
tmp = a * (x * t);
} else {
tmp = b * (a * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-5.8d+31)) then
tmp = a * (x * t)
else
tmp = b * (a * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -5.8e+31) {
tmp = a * (x * t);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -5.8e+31: tmp = a * (x * t) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -5.8e+31) tmp = Float64(a * Float64(x * t)); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -5.8e+31) tmp = a * (x * t); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -5.8e+31], N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -5.8 \cdot 10^{+31}:\\
\;\;\;\;a \cdot \left(x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if y < -5.8000000000000001e31Initial program 56.5%
Taylor expanded in a around inf 22.6%
associate-*r*22.6%
neg-mul-122.6%
cancel-sign-sub22.6%
+-commutative22.6%
mul-1-neg22.6%
unsub-neg22.6%
*-commutative22.6%
*-commutative22.6%
Simplified22.6%
Taylor expanded in i around 0 14.5%
neg-mul-114.5%
distribute-rgt-neg-in14.5%
Simplified14.5%
expm1-log1p-u7.3%
expm1-udef7.2%
*-commutative7.2%
associate-*r*8.7%
add-sqr-sqrt8.2%
sqrt-unprod12.6%
sqr-neg12.6%
sqrt-unprod4.0%
add-sqr-sqrt9.4%
Applied egg-rr9.4%
expm1-def9.3%
expm1-log1p16.1%
associate-*l*16.1%
*-commutative16.1%
Simplified16.1%
if -5.8000000000000001e31 < y Initial program 77.0%
Taylor expanded in y around 0 69.0%
*-commutative69.0%
*-commutative69.0%
*-commutative69.0%
*-rgt-identity69.0%
cancel-sign-sub-inv69.0%
Simplified68.0%
Taylor expanded in j around inf 56.9%
Taylor expanded in c around 0 23.0%
associate-*r*22.4%
*-commutative22.4%
associate-*l*24.3%
Simplified24.3%
Final simplification22.3%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= a 86000000000.0) (* c (* t j)) (* b (* a i))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= 86000000000.0) {
tmp = c * (t * j);
} else {
tmp = b * (a * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (a <= 86000000000.0d0) then
tmp = c * (t * j)
else
tmp = b * (a * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (a <= 86000000000.0) {
tmp = c * (t * j);
} else {
tmp = b * (a * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if a <= 86000000000.0: tmp = c * (t * j) else: tmp = b * (a * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (a <= 86000000000.0) tmp = Float64(c * Float64(t * j)); else tmp = Float64(b * Float64(a * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (a <= 86000000000.0) tmp = c * (t * j); else tmp = b * (a * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[a, 86000000000.0], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq 86000000000:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\end{array}
\end{array}
if a < 8.6e10Initial program 75.4%
Taylor expanded in j around inf 42.0%
Taylor expanded in c around inf 30.4%
*-commutative30.4%
Simplified30.4%
if 8.6e10 < a Initial program 64.3%
Taylor expanded in y around 0 61.0%
*-commutative61.0%
*-commutative61.0%
*-commutative61.0%
*-rgt-identity61.0%
cancel-sign-sub-inv61.0%
Simplified64.9%
Taylor expanded in j around inf 50.0%
Taylor expanded in c around 0 35.0%
associate-*r*37.5%
*-commutative37.5%
associate-*l*36.2%
Simplified36.2%
Final simplification32.2%
(FPCore (x y z t a b c i j) :precision binary64 (* a (* b i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = a * (b * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return a * (b * i);
}
def code(x, y, z, t, a, b, c, i, j): return a * (b * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(a * Float64(b * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = a * (b * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
a \cdot \left(b \cdot i\right)
\end{array}
Initial program 72.1%
Taylor expanded in a around inf 37.8%
associate-*r*37.8%
neg-mul-137.8%
cancel-sign-sub37.8%
+-commutative37.8%
mul-1-neg37.8%
unsub-neg37.8%
*-commutative37.8%
*-commutative37.8%
Simplified37.8%
Taylor expanded in i around inf 20.3%
Final simplification20.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t_1\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
herbie shell --seed 2023279
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:herbie-target
(if (< t -8.120978919195912e-33) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -4.712553818218485e-169) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (if (< t -7.633533346031584e-308) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 1.0535888557455487e-139) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))