
(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 32 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c))))
(t_2 (+ (+ (* x (- (* y z) (* t a))) t_1) (* j (- (* t c) (* y i))))))
(if (<= t_2 (- INFINITY))
(* y (+ (* x z) (- (/ (+ (* t (- (* c j) (* x a))) t_1) y) (* i j))))
(if (<= t_2 INFINITY)
t_2
(* y (* i (+ (* a (/ b y)) (- (* x (/ z i)) 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 * ((a * i) - (z * c));
double t_2 = ((x * ((y * z) - (t * a))) + t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = y * ((x * z) + ((((t * ((c * j) - (x * a))) + t_1) / y) - (i * j)));
} else if (t_2 <= ((double) INFINITY)) {
tmp = t_2;
} else {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double t_2 = ((x * ((y * z) - (t * a))) + t_1) + (j * ((t * c) - (y * i)));
double tmp;
if (t_2 <= -Double.POSITIVE_INFINITY) {
tmp = y * ((x * z) + ((((t * ((c * j) - (x * a))) + t_1) / y) - (i * j)));
} else if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = t_2;
} else {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) t_2 = ((x * ((y * z) - (t * a))) + t_1) + (j * ((t * c) - (y * i))) tmp = 0 if t_2 <= -math.inf: tmp = y * ((x * z) + ((((t * ((c * j) - (x * a))) + t_1) / y) - (i * j))) elif t_2 <= math.inf: tmp = t_2 else: tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) t_2 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(y * Float64(Float64(x * z) + Float64(Float64(Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + t_1) / y) - Float64(i * j)))); elseif (t_2 <= Inf) tmp = t_2; else tmp = Float64(y * Float64(i * Float64(Float64(a * Float64(b / y)) + Float64(Float64(x * Float64(z / i)) - j)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); t_2 = ((x * ((y * z) - (t * a))) + t_1) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_2 <= -Inf) tmp = y * ((x * z) + ((((t * ((c * j) - (x * a))) + t_1) / y) - (i * j))); elseif (t_2 <= Inf) tmp = t_2; else tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(y * N[(N[(x * z), $MachinePrecision] + N[(N[(N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] / y), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], t$95$2, N[(y * N[(i * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(z / i), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
t_2 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;y \cdot \left(x \cdot z + \left(\frac{t \cdot \left(c \cdot j - x \cdot a\right) + t\_1}{y} - i \cdot j\right)\right)\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(i \cdot \left(a \cdot \frac{b}{y} + \left(x \cdot \frac{z}{i} - j\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 80.6%
+-commutative80.6%
fma-define80.6%
*-commutative80.6%
*-commutative80.6%
cancel-sign-sub-inv80.6%
cancel-sign-sub80.6%
sub-neg80.6%
sub-neg80.6%
*-commutative80.6%
fma-neg80.6%
*-commutative80.6%
distribute-rgt-neg-out80.6%
remove-double-neg80.6%
*-commutative80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in y around -inf 84.8%
Simplified87.8%
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)))) < +inf.0Initial program 95.1%
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-define0.0%
*-commutative0.0%
*-commutative0.0%
cancel-sign-sub-inv0.0%
cancel-sign-sub0.0%
sub-neg0.0%
sub-neg0.0%
*-commutative0.0%
fma-neg2.0%
*-commutative2.0%
distribute-rgt-neg-out2.0%
remove-double-neg2.0%
*-commutative2.0%
*-commutative2.0%
Simplified2.0%
Taylor expanded in y around -inf 27.4%
Simplified33.3%
Taylor expanded in i around inf 51.2%
Taylor expanded in i around inf 55.1%
mul-1-neg55.1%
unsub-neg55.1%
associate-/l*60.8%
associate-/l*62.7%
Simplified62.7%
Final simplification86.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY)
t_1
(* y (* i (+ (* a (/ b y)) (- (* x (/ z i)) j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= Double.POSITIVE_INFINITY) {
tmp = t_1;
} else {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))) tmp = 0 if t_1 <= math.inf: tmp = t_1 else: tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(y * Float64(i * Float64(Float64(a * Float64(b / y)) + Float64(Float64(x * Float64(z / i)) - j)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i))); tmp = 0.0; if (t_1 <= Inf) tmp = t_1; else tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(y * N[(i * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(z / i), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;t\_1 \leq \infty:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(i \cdot \left(a \cdot \frac{b}{y} + \left(x \cdot \frac{z}{i} - j\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 90.6%
if +inf.0 < (+.f64 (-.f64 (*.f64 x (-.f64 (*.f64 y z) (*.f64 t a))) (*.f64 b (-.f64 (*.f64 c z) (*.f64 i a)))) (*.f64 j (-.f64 (*.f64 c t) (*.f64 i y)))) Initial program 0.0%
+-commutative0.0%
fma-define0.0%
*-commutative0.0%
*-commutative0.0%
cancel-sign-sub-inv0.0%
cancel-sign-sub0.0%
sub-neg0.0%
sub-neg0.0%
*-commutative0.0%
fma-neg2.0%
*-commutative2.0%
distribute-rgt-neg-out2.0%
remove-double-neg2.0%
*-commutative2.0%
*-commutative2.0%
Simplified2.0%
Taylor expanded in y around -inf 27.4%
Simplified33.3%
Taylor expanded in i around inf 51.2%
Taylor expanded in i around inf 55.1%
mul-1-neg55.1%
unsub-neg55.1%
associate-/l*60.8%
associate-/l*62.7%
Simplified62.7%
Final simplification85.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (* z (- c))))
(t_2 (* i (* a b)))
(t_3 (* i (* j (- y))))
(t_4 (* t (* c j))))
(if (<= a -3e+36)
(* t (* x (- a)))
(if (<= a -7e-43)
t_2
(if (<= a 5.2e-238)
t_3
(if (<= a 2.7e-194)
t_1
(if (<= a 8e-181)
t_3
(if (<= a 1.65e-159)
t_4
(if (<= a 3.1e-58)
t_1
(if (<= a 1.8e-32)
t_4
(if (<= a 8.5e+15)
(* x (* y z))
(if (<= a 2.2e+258) t_2 (* (- a) (* x t))))))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = i * (a * b);
double t_3 = i * (j * -y);
double t_4 = t * (c * j);
double tmp;
if (a <= -3e+36) {
tmp = t * (x * -a);
} else if (a <= -7e-43) {
tmp = t_2;
} else if (a <= 5.2e-238) {
tmp = t_3;
} else if (a <= 2.7e-194) {
tmp = t_1;
} else if (a <= 8e-181) {
tmp = t_3;
} else if (a <= 1.65e-159) {
tmp = t_4;
} else if (a <= 3.1e-58) {
tmp = t_1;
} else if (a <= 1.8e-32) {
tmp = t_4;
} else if (a <= 8.5e+15) {
tmp = x * (y * z);
} else if (a <= 2.2e+258) {
tmp = t_2;
} else {
tmp = -a * (x * t);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = b * (z * -c)
t_2 = i * (a * b)
t_3 = i * (j * -y)
t_4 = t * (c * j)
if (a <= (-3d+36)) then
tmp = t * (x * -a)
else if (a <= (-7d-43)) then
tmp = t_2
else if (a <= 5.2d-238) then
tmp = t_3
else if (a <= 2.7d-194) then
tmp = t_1
else if (a <= 8d-181) then
tmp = t_3
else if (a <= 1.65d-159) then
tmp = t_4
else if (a <= 3.1d-58) then
tmp = t_1
else if (a <= 1.8d-32) then
tmp = t_4
else if (a <= 8.5d+15) then
tmp = x * (y * z)
else if (a <= 2.2d+258) then
tmp = t_2
else
tmp = -a * (x * t)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * (z * -c);
double t_2 = i * (a * b);
double t_3 = i * (j * -y);
double t_4 = t * (c * j);
double tmp;
if (a <= -3e+36) {
tmp = t * (x * -a);
} else if (a <= -7e-43) {
tmp = t_2;
} else if (a <= 5.2e-238) {
tmp = t_3;
} else if (a <= 2.7e-194) {
tmp = t_1;
} else if (a <= 8e-181) {
tmp = t_3;
} else if (a <= 1.65e-159) {
tmp = t_4;
} else if (a <= 3.1e-58) {
tmp = t_1;
} else if (a <= 1.8e-32) {
tmp = t_4;
} else if (a <= 8.5e+15) {
tmp = x * (y * z);
} else if (a <= 2.2e+258) {
tmp = t_2;
} else {
tmp = -a * (x * t);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * (z * -c) t_2 = i * (a * b) t_3 = i * (j * -y) t_4 = t * (c * j) tmp = 0 if a <= -3e+36: tmp = t * (x * -a) elif a <= -7e-43: tmp = t_2 elif a <= 5.2e-238: tmp = t_3 elif a <= 2.7e-194: tmp = t_1 elif a <= 8e-181: tmp = t_3 elif a <= 1.65e-159: tmp = t_4 elif a <= 3.1e-58: tmp = t_1 elif a <= 1.8e-32: tmp = t_4 elif a <= 8.5e+15: tmp = x * (y * z) elif a <= 2.2e+258: tmp = t_2 else: tmp = -a * (x * t) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(z * Float64(-c))) t_2 = Float64(i * Float64(a * b)) t_3 = Float64(i * Float64(j * Float64(-y))) t_4 = Float64(t * Float64(c * j)) tmp = 0.0 if (a <= -3e+36) tmp = Float64(t * Float64(x * Float64(-a))); elseif (a <= -7e-43) tmp = t_2; elseif (a <= 5.2e-238) tmp = t_3; elseif (a <= 2.7e-194) tmp = t_1; elseif (a <= 8e-181) tmp = t_3; elseif (a <= 1.65e-159) tmp = t_4; elseif (a <= 3.1e-58) tmp = t_1; elseif (a <= 1.8e-32) tmp = t_4; elseif (a <= 8.5e+15) tmp = Float64(x * Float64(y * z)); elseif (a <= 2.2e+258) tmp = t_2; else tmp = Float64(Float64(-a) * Float64(x * t)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * (z * -c); t_2 = i * (a * b); t_3 = i * (j * -y); t_4 = t * (c * j); tmp = 0.0; if (a <= -3e+36) tmp = t * (x * -a); elseif (a <= -7e-43) tmp = t_2; elseif (a <= 5.2e-238) tmp = t_3; elseif (a <= 2.7e-194) tmp = t_1; elseif (a <= 8e-181) tmp = t_3; elseif (a <= 1.65e-159) tmp = t_4; elseif (a <= 3.1e-58) tmp = t_1; elseif (a <= 1.8e-32) tmp = t_4; elseif (a <= 8.5e+15) tmp = x * (y * z); elseif (a <= 2.2e+258) tmp = t_2; else tmp = -a * (x * t); 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[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(i * N[(j * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -3e+36], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, -7e-43], t$95$2, If[LessEqual[a, 5.2e-238], t$95$3, If[LessEqual[a, 2.7e-194], t$95$1, If[LessEqual[a, 8e-181], t$95$3, If[LessEqual[a, 1.65e-159], t$95$4, If[LessEqual[a, 3.1e-58], t$95$1, If[LessEqual[a, 1.8e-32], t$95$4, If[LessEqual[a, 8.5e+15], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 2.2e+258], t$95$2, N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(z \cdot \left(-c\right)\right)\\
t_2 := i \cdot \left(a \cdot b\right)\\
t_3 := i \cdot \left(j \cdot \left(-y\right)\right)\\
t_4 := t \cdot \left(c \cdot j\right)\\
\mathbf{if}\;a \leq -3 \cdot 10^{+36}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{elif}\;a \leq -7 \cdot 10^{-43}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq 5.2 \cdot 10^{-238}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;a \leq 2.7 \cdot 10^{-194}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 8 \cdot 10^{-181}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;a \leq 1.65 \cdot 10^{-159}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;a \leq 3.1 \cdot 10^{-58}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.8 \cdot 10^{-32}:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;a \leq 8.5 \cdot 10^{+15}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;a \leq 2.2 \cdot 10^{+258}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\
\end{array}
\end{array}
if a < -3e36Initial program 58.5%
+-commutative58.5%
fma-define58.5%
*-commutative58.5%
*-commutative58.5%
cancel-sign-sub-inv58.5%
cancel-sign-sub58.5%
sub-neg58.5%
sub-neg58.5%
*-commutative58.5%
fma-neg58.5%
*-commutative58.5%
distribute-rgt-neg-out58.5%
remove-double-neg58.5%
*-commutative58.5%
*-commutative58.5%
Simplified58.5%
Taylor expanded in t around inf 57.5%
+-commutative57.5%
mul-1-neg57.5%
unsub-neg57.5%
*-commutative57.5%
Simplified57.5%
Taylor expanded in j around 0 53.5%
neg-mul-153.5%
distribute-lft-neg-in53.5%
*-commutative53.5%
Simplified53.5%
if -3e36 < a < -6.99999999999999994e-43 or 8.5e15 < a < 2.19999999999999983e258Initial program 68.3%
+-commutative68.3%
fma-define68.3%
*-commutative68.3%
*-commutative68.3%
cancel-sign-sub-inv68.3%
cancel-sign-sub68.3%
sub-neg68.3%
sub-neg68.3%
*-commutative68.3%
fma-neg68.3%
*-commutative68.3%
distribute-rgt-neg-out68.3%
remove-double-neg68.3%
*-commutative68.3%
*-commutative68.3%
Simplified68.3%
Taylor expanded in y around -inf 66.0%
Simplified68.9%
Taylor expanded in i around inf 55.8%
Taylor expanded in a around inf 43.2%
associate-*r*46.0%
Simplified46.0%
if -6.99999999999999994e-43 < a < 5.2000000000000002e-238 or 2.7e-194 < a < 8.00000000000000038e-181Initial program 89.1%
Taylor expanded in i around inf 60.1%
*-commutative60.1%
associate-*r*67.0%
Simplified67.0%
Taylor expanded in y around inf 39.6%
associate-*r*39.6%
neg-mul-139.6%
Simplified39.6%
if 5.2000000000000002e-238 < a < 2.7e-194 or 1.6500000000000001e-159 < a < 3.0999999999999999e-58Initial program 84.2%
+-commutative84.2%
fma-define84.2%
*-commutative84.2%
*-commutative84.2%
cancel-sign-sub-inv84.2%
cancel-sign-sub84.2%
sub-neg84.2%
sub-neg84.2%
*-commutative84.2%
fma-neg84.2%
*-commutative84.2%
distribute-rgt-neg-out84.2%
remove-double-neg84.2%
*-commutative84.2%
*-commutative84.2%
Simplified84.2%
Taylor expanded in c around inf 37.2%
Taylor expanded in j around 0 39.7%
associate-*r*39.7%
neg-mul-139.7%
Simplified39.7%
if 8.00000000000000038e-181 < a < 1.6500000000000001e-159 or 3.0999999999999999e-58 < a < 1.79999999999999996e-32Initial program 63.9%
+-commutative63.9%
fma-define63.9%
*-commutative63.9%
*-commutative63.9%
cancel-sign-sub-inv63.9%
cancel-sign-sub63.9%
sub-neg63.9%
sub-neg63.9%
*-commutative63.9%
fma-neg63.9%
*-commutative63.9%
distribute-rgt-neg-out63.9%
remove-double-neg63.9%
*-commutative63.9%
*-commutative63.9%
Simplified63.9%
Taylor expanded in t around inf 63.2%
+-commutative63.2%
mul-1-neg63.2%
unsub-neg63.2%
*-commutative63.2%
Simplified63.2%
Taylor expanded in j around inf 63.3%
if 1.79999999999999996e-32 < a < 8.5e15Initial program 69.8%
+-commutative69.8%
fma-define69.8%
*-commutative69.8%
*-commutative69.8%
cancel-sign-sub-inv69.8%
cancel-sign-sub69.8%
sub-neg69.8%
sub-neg69.8%
*-commutative69.8%
fma-neg69.8%
*-commutative69.8%
distribute-rgt-neg-out69.8%
remove-double-neg69.8%
*-commutative69.8%
*-commutative69.8%
Simplified69.8%
Taylor expanded in y around -inf 69.8%
Simplified59.8%
Taylor expanded in i around inf 80.9%
Taylor expanded in i around 0 89.9%
if 2.19999999999999983e258 < a Initial program 38.5%
Taylor expanded in x around inf 53.8%
Taylor expanded in y around 0 69.8%
+-commutative69.8%
mul-1-neg69.8%
unsub-neg69.8%
Simplified69.8%
Taylor expanded in c around 0 62.3%
*-commutative62.3%
neg-mul-162.3%
distribute-rgt-neg-in62.3%
distribute-rgt-neg-in62.3%
Simplified62.3%
Final simplification48.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (- (* c (* t j)) (* i (- (* y j) (* a b)))))
(t_2 (* j (- (* t c) (* y i))))
(t_3 (+ t_2 (* b (* a i))))
(t_4 (* x (- (* y z) (* t a))))
(t_5 (- t_4 (* b (* z c)))))
(if (<= j -2.9e+116)
t_3
(if (<= j -7.5e-52)
(+ t_4 t_2)
(if (<= j -2.35e-236)
(* y (* i (+ (* a (/ b y)) (- (* x (/ z i)) j))))
(if (<= j 4.7e-299)
(* (* x y) (- z (* a (/ t y))))
(if (<= j 1e-213)
t_1
(if (<= j 3.8e-45)
t_5
(if (<= j 2.05e+15) t_1 (if (<= j 3.7e+46) t_5 t_3))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (c * (t * j)) - (i * ((y * j) - (a * b)));
double t_2 = j * ((t * c) - (y * i));
double t_3 = t_2 + (b * (a * i));
double t_4 = x * ((y * z) - (t * a));
double t_5 = t_4 - (b * (z * c));
double tmp;
if (j <= -2.9e+116) {
tmp = t_3;
} else if (j <= -7.5e-52) {
tmp = t_4 + t_2;
} else if (j <= -2.35e-236) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (j <= 4.7e-299) {
tmp = (x * y) * (z - (a * (t / y)));
} else if (j <= 1e-213) {
tmp = t_1;
} else if (j <= 3.8e-45) {
tmp = t_5;
} else if (j <= 2.05e+15) {
tmp = t_1;
} else if (j <= 3.7e+46) {
tmp = t_5;
} else {
tmp = t_3;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: t_5
real(8) :: tmp
t_1 = (c * (t * j)) - (i * ((y * j) - (a * b)))
t_2 = j * ((t * c) - (y * i))
t_3 = t_2 + (b * (a * i))
t_4 = x * ((y * z) - (t * a))
t_5 = t_4 - (b * (z * c))
if (j <= (-2.9d+116)) then
tmp = t_3
else if (j <= (-7.5d-52)) then
tmp = t_4 + t_2
else if (j <= (-2.35d-236)) then
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)))
else if (j <= 4.7d-299) then
tmp = (x * y) * (z - (a * (t / y)))
else if (j <= 1d-213) then
tmp = t_1
else if (j <= 3.8d-45) then
tmp = t_5
else if (j <= 2.05d+15) then
tmp = t_1
else if (j <= 3.7d+46) then
tmp = t_5
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (c * (t * j)) - (i * ((y * j) - (a * b)));
double t_2 = j * ((t * c) - (y * i));
double t_3 = t_2 + (b * (a * i));
double t_4 = x * ((y * z) - (t * a));
double t_5 = t_4 - (b * (z * c));
double tmp;
if (j <= -2.9e+116) {
tmp = t_3;
} else if (j <= -7.5e-52) {
tmp = t_4 + t_2;
} else if (j <= -2.35e-236) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (j <= 4.7e-299) {
tmp = (x * y) * (z - (a * (t / y)));
} else if (j <= 1e-213) {
tmp = t_1;
} else if (j <= 3.8e-45) {
tmp = t_5;
} else if (j <= 2.05e+15) {
tmp = t_1;
} else if (j <= 3.7e+46) {
tmp = t_5;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (c * (t * j)) - (i * ((y * j) - (a * b))) t_2 = j * ((t * c) - (y * i)) t_3 = t_2 + (b * (a * i)) t_4 = x * ((y * z) - (t * a)) t_5 = t_4 - (b * (z * c)) tmp = 0 if j <= -2.9e+116: tmp = t_3 elif j <= -7.5e-52: tmp = t_4 + t_2 elif j <= -2.35e-236: tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))) elif j <= 4.7e-299: tmp = (x * y) * (z - (a * (t / y))) elif j <= 1e-213: tmp = t_1 elif j <= 3.8e-45: tmp = t_5 elif j <= 2.05e+15: tmp = t_1 elif j <= 3.7e+46: tmp = t_5 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(c * Float64(t * j)) - Float64(i * Float64(Float64(y * j) - Float64(a * b)))) t_2 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) t_3 = Float64(t_2 + Float64(b * Float64(a * i))) t_4 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) t_5 = Float64(t_4 - Float64(b * Float64(z * c))) tmp = 0.0 if (j <= -2.9e+116) tmp = t_3; elseif (j <= -7.5e-52) tmp = Float64(t_4 + t_2); elseif (j <= -2.35e-236) tmp = Float64(y * Float64(i * Float64(Float64(a * Float64(b / y)) + Float64(Float64(x * Float64(z / i)) - j)))); elseif (j <= 4.7e-299) tmp = Float64(Float64(x * y) * Float64(z - Float64(a * Float64(t / y)))); elseif (j <= 1e-213) tmp = t_1; elseif (j <= 3.8e-45) tmp = t_5; elseif (j <= 2.05e+15) tmp = t_1; elseif (j <= 3.7e+46) tmp = t_5; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (c * (t * j)) - (i * ((y * j) - (a * b))); t_2 = j * ((t * c) - (y * i)); t_3 = t_2 + (b * (a * i)); t_4 = x * ((y * z) - (t * a)); t_5 = t_4 - (b * (z * c)); tmp = 0.0; if (j <= -2.9e+116) tmp = t_3; elseif (j <= -7.5e-52) tmp = t_4 + t_2; elseif (j <= -2.35e-236) tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))); elseif (j <= 4.7e-299) tmp = (x * y) * (z - (a * (t / y))); elseif (j <= 1e-213) tmp = t_1; elseif (j <= 3.8e-45) tmp = t_5; elseif (j <= 2.05e+15) tmp = t_1; elseif (j <= 3.7e+46) tmp = t_5; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(y * j), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$4 - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -2.9e+116], t$95$3, If[LessEqual[j, -7.5e-52], N[(t$95$4 + t$95$2), $MachinePrecision], If[LessEqual[j, -2.35e-236], N[(y * N[(i * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(z / i), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 4.7e-299], N[(N[(x * y), $MachinePrecision] * N[(z - N[(a * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1e-213], t$95$1, If[LessEqual[j, 3.8e-45], t$95$5, If[LessEqual[j, 2.05e+15], t$95$1, If[LessEqual[j, 3.7e+46], t$95$5, t$95$3]]]]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j\right) - i \cdot \left(y \cdot j - a \cdot b\right)\\
t_2 := j \cdot \left(t \cdot c - y \cdot i\right)\\
t_3 := t\_2 + b \cdot \left(a \cdot i\right)\\
t_4 := x \cdot \left(y \cdot z - t \cdot a\right)\\
t_5 := t\_4 - b \cdot \left(z \cdot c\right)\\
\mathbf{if}\;j \leq -2.9 \cdot 10^{+116}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;j \leq -7.5 \cdot 10^{-52}:\\
\;\;\;\;t\_4 + t\_2\\
\mathbf{elif}\;j \leq -2.35 \cdot 10^{-236}:\\
\;\;\;\;y \cdot \left(i \cdot \left(a \cdot \frac{b}{y} + \left(x \cdot \frac{z}{i} - j\right)\right)\right)\\
\mathbf{elif}\;j \leq 4.7 \cdot 10^{-299}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \left(z - a \cdot \frac{t}{y}\right)\\
\mathbf{elif}\;j \leq 10^{-213}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 3.8 \cdot 10^{-45}:\\
\;\;\;\;t\_5\\
\mathbf{elif}\;j \leq 2.05 \cdot 10^{+15}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 3.7 \cdot 10^{+46}:\\
\;\;\;\;t\_5\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if j < -2.9000000000000001e116 or 3.6999999999999999e46 < j Initial program 75.5%
Taylor expanded in i around inf 73.7%
*-commutative73.7%
associate-*r*76.0%
Simplified76.0%
if -2.9000000000000001e116 < j < -7.50000000000000006e-52Initial program 83.6%
Taylor expanded in x around inf 84.0%
if -7.50000000000000006e-52 < j < -2.35000000000000013e-236Initial program 56.4%
+-commutative56.4%
fma-define56.4%
*-commutative56.4%
*-commutative56.4%
cancel-sign-sub-inv56.4%
cancel-sign-sub56.4%
sub-neg56.4%
sub-neg56.4%
*-commutative56.4%
fma-neg56.4%
*-commutative56.4%
distribute-rgt-neg-out56.4%
remove-double-neg56.4%
*-commutative56.4%
*-commutative56.4%
Simplified56.4%
Taylor expanded in y around -inf 78.0%
Simplified80.4%
Taylor expanded in i around inf 70.3%
Taylor expanded in i around inf 67.8%
mul-1-neg67.8%
unsub-neg67.8%
associate-/l*72.8%
associate-/l*75.3%
Simplified75.3%
if -2.35000000000000013e-236 < j < 4.6999999999999997e-299Initial program 65.5%
+-commutative65.5%
fma-define65.5%
*-commutative65.5%
*-commutative65.5%
cancel-sign-sub-inv65.5%
cancel-sign-sub65.5%
sub-neg65.5%
sub-neg65.5%
*-commutative65.5%
fma-neg69.4%
*-commutative69.4%
distribute-rgt-neg-out69.4%
remove-double-neg69.4%
*-commutative69.4%
*-commutative69.4%
Simplified69.4%
Taylor expanded in y around -inf 76.7%
Simplified73.0%
Taylor expanded in x around inf 81.1%
associate-*r*81.1%
*-commutative81.1%
mul-1-neg81.1%
unsub-neg81.1%
associate-/l*77.3%
Simplified77.3%
if 4.6999999999999997e-299 < j < 9.9999999999999995e-214 or 3.79999999999999997e-45 < j < 2.05e15Initial program 71.7%
Taylor expanded in i around inf 61.8%
*-commutative61.8%
associate-*r*61.7%
Simplified61.7%
Taylor expanded in i around 0 78.9%
if 9.9999999999999995e-214 < j < 3.79999999999999997e-45 or 2.05e15 < j < 3.6999999999999999e46Initial program 77.4%
Taylor expanded in c around inf 77.5%
*-commutative77.5%
associate-*l*75.2%
*-commutative75.2%
Simplified75.2%
Taylor expanded in j around 0 72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Final simplification76.9%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* (- a) (* x t))) (t_2 (* b (* z (- c)))))
(if (<= z -5.9e+32)
t_2
(if (<= z -9e-164)
(* c (* t j))
(if (<= z -2.9e-260)
(* a (* b i))
(if (<= z 1.1e-172)
(* j (* y (- i)))
(if (<= z 7.2e-117)
t_1
(if (<= z 2e-37)
(* i (* j (- y)))
(if (<= z 2.4e-14)
t_1
(if (<= z 7e+68) (* i (* a b)) t_2))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double t_2 = b * (z * -c);
double tmp;
if (z <= -5.9e+32) {
tmp = t_2;
} else if (z <= -9e-164) {
tmp = c * (t * j);
} else if (z <= -2.9e-260) {
tmp = a * (b * i);
} else if (z <= 1.1e-172) {
tmp = j * (y * -i);
} else if (z <= 7.2e-117) {
tmp = t_1;
} else if (z <= 2e-37) {
tmp = i * (j * -y);
} else if (z <= 2.4e-14) {
tmp = t_1;
} else if (z <= 7e+68) {
tmp = i * (a * b);
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = -a * (x * t)
t_2 = b * (z * -c)
if (z <= (-5.9d+32)) then
tmp = t_2
else if (z <= (-9d-164)) then
tmp = c * (t * j)
else if (z <= (-2.9d-260)) then
tmp = a * (b * i)
else if (z <= 1.1d-172) then
tmp = j * (y * -i)
else if (z <= 7.2d-117) then
tmp = t_1
else if (z <= 2d-37) then
tmp = i * (j * -y)
else if (z <= 2.4d-14) then
tmp = t_1
else if (z <= 7d+68) then
tmp = i * (a * b)
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = -a * (x * t);
double t_2 = b * (z * -c);
double tmp;
if (z <= -5.9e+32) {
tmp = t_2;
} else if (z <= -9e-164) {
tmp = c * (t * j);
} else if (z <= -2.9e-260) {
tmp = a * (b * i);
} else if (z <= 1.1e-172) {
tmp = j * (y * -i);
} else if (z <= 7.2e-117) {
tmp = t_1;
} else if (z <= 2e-37) {
tmp = i * (j * -y);
} else if (z <= 2.4e-14) {
tmp = t_1;
} else if (z <= 7e+68) {
tmp = i * (a * b);
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = -a * (x * t) t_2 = b * (z * -c) tmp = 0 if z <= -5.9e+32: tmp = t_2 elif z <= -9e-164: tmp = c * (t * j) elif z <= -2.9e-260: tmp = a * (b * i) elif z <= 1.1e-172: tmp = j * (y * -i) elif z <= 7.2e-117: tmp = t_1 elif z <= 2e-37: tmp = i * (j * -y) elif z <= 2.4e-14: tmp = t_1 elif z <= 7e+68: tmp = i * (a * b) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(-a) * Float64(x * t)) t_2 = Float64(b * Float64(z * Float64(-c))) tmp = 0.0 if (z <= -5.9e+32) tmp = t_2; elseif (z <= -9e-164) tmp = Float64(c * Float64(t * j)); elseif (z <= -2.9e-260) tmp = Float64(a * Float64(b * i)); elseif (z <= 1.1e-172) tmp = Float64(j * Float64(y * Float64(-i))); elseif (z <= 7.2e-117) tmp = t_1; elseif (z <= 2e-37) tmp = Float64(i * Float64(j * Float64(-y))); elseif (z <= 2.4e-14) tmp = t_1; elseif (z <= 7e+68) tmp = Float64(i * Float64(a * b)); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = -a * (x * t); t_2 = b * (z * -c); tmp = 0.0; if (z <= -5.9e+32) tmp = t_2; elseif (z <= -9e-164) tmp = c * (t * j); elseif (z <= -2.9e-260) tmp = a * (b * i); elseif (z <= 1.1e-172) tmp = j * (y * -i); elseif (z <= 7.2e-117) tmp = t_1; elseif (z <= 2e-37) tmp = i * (j * -y); elseif (z <= 2.4e-14) tmp = t_1; elseif (z <= 7e+68) tmp = i * (a * b); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5.9e+32], t$95$2, If[LessEqual[z, -9e-164], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.9e-260], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e-172], N[(j * N[(y * (-i)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.2e-117], t$95$1, If[LessEqual[z, 2e-37], N[(i * N[(j * (-y)), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.4e-14], t$95$1, If[LessEqual[z, 7e+68], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(-a\right) \cdot \left(x \cdot t\right)\\
t_2 := b \cdot \left(z \cdot \left(-c\right)\right)\\
\mathbf{if}\;z \leq -5.9 \cdot 10^{+32}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -9 \cdot 10^{-164}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;z \leq -2.9 \cdot 10^{-260}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{-172}:\\
\;\;\;\;j \cdot \left(y \cdot \left(-i\right)\right)\\
\mathbf{elif}\;z \leq 7.2 \cdot 10^{-117}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 2 \cdot 10^{-37}:\\
\;\;\;\;i \cdot \left(j \cdot \left(-y\right)\right)\\
\mathbf{elif}\;z \leq 2.4 \cdot 10^{-14}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 7 \cdot 10^{+68}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -5.89999999999999965e32 or 6.99999999999999955e68 < z Initial program 62.0%
+-commutative62.0%
fma-define62.0%
*-commutative62.0%
*-commutative62.0%
cancel-sign-sub-inv62.0%
cancel-sign-sub62.0%
sub-neg62.0%
sub-neg62.0%
*-commutative62.0%
fma-neg63.0%
*-commutative63.0%
distribute-rgt-neg-out63.0%
remove-double-neg63.0%
*-commutative63.0%
*-commutative63.0%
Simplified63.0%
Taylor expanded in c around inf 46.8%
Taylor expanded in j around 0 44.0%
associate-*r*44.0%
neg-mul-144.0%
Simplified44.0%
if -5.89999999999999965e32 < z < -8.9999999999999995e-164Initial program 79.4%
+-commutative79.4%
fma-define79.4%
*-commutative79.4%
*-commutative79.4%
cancel-sign-sub-inv79.4%
cancel-sign-sub79.4%
sub-neg79.4%
sub-neg79.4%
*-commutative79.4%
fma-neg79.4%
*-commutative79.4%
distribute-rgt-neg-out79.4%
remove-double-neg79.4%
*-commutative79.4%
*-commutative79.4%
Simplified79.4%
Taylor expanded in c around inf 40.0%
Taylor expanded in j around inf 35.9%
if -8.9999999999999995e-164 < z < -2.8999999999999999e-260Initial program 78.1%
+-commutative78.1%
fma-define78.1%
*-commutative78.1%
*-commutative78.1%
cancel-sign-sub-inv78.1%
cancel-sign-sub78.1%
sub-neg78.1%
sub-neg78.1%
*-commutative78.1%
fma-neg78.1%
*-commutative78.1%
distribute-rgt-neg-out78.1%
remove-double-neg78.1%
*-commutative78.1%
*-commutative78.1%
Simplified78.1%
Taylor expanded in y around -inf 56.7%
Simplified60.3%
Taylor expanded in i around inf 56.4%
Taylor expanded in a around inf 55.8%
*-commutative55.8%
Simplified55.8%
if -2.8999999999999999e-260 < z < 1.10000000000000004e-172Initial program 85.3%
Taylor expanded in i around inf 79.1%
*-commutative79.1%
associate-*r*74.3%
Simplified74.3%
Taylor expanded in y around inf 36.1%
mul-1-neg36.1%
associate-*r*40.6%
*-commutative40.6%
associate-*l*43.1%
distribute-lft-neg-in43.1%
Simplified43.1%
if 1.10000000000000004e-172 < z < 7.2000000000000001e-117 or 2.00000000000000013e-37 < z < 2.4e-14Initial program 83.4%
Taylor expanded in x around inf 78.4%
Taylor expanded in y around 0 61.9%
+-commutative61.9%
mul-1-neg61.9%
unsub-neg61.9%
Simplified61.9%
Taylor expanded in c around 0 67.2%
*-commutative67.2%
neg-mul-167.2%
distribute-rgt-neg-in67.2%
distribute-rgt-neg-in67.2%
Simplified67.2%
if 7.2000000000000001e-117 < z < 2.00000000000000013e-37Initial program 75.0%
Taylor expanded in i around inf 52.0%
*-commutative52.0%
associate-*r*56.5%
Simplified56.5%
Taylor expanded in y around inf 42.5%
associate-*r*42.5%
neg-mul-142.5%
Simplified42.5%
if 2.4e-14 < z < 6.99999999999999955e68Initial program 72.4%
+-commutative72.4%
fma-define72.4%
*-commutative72.4%
*-commutative72.4%
cancel-sign-sub-inv72.4%
cancel-sign-sub72.4%
sub-neg72.4%
sub-neg72.4%
*-commutative72.4%
fma-neg72.4%
*-commutative72.4%
distribute-rgt-neg-out72.4%
remove-double-neg72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Taylor expanded in y around -inf 73.0%
Simplified78.5%
Taylor expanded in i around inf 56.6%
Taylor expanded in a around inf 45.8%
associate-*r*50.8%
Simplified50.8%
Final simplification45.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (* b i)))
(t_2 (* (* x y) (- z (* a (/ t y)))))
(t_3 (+ (* j (- (* t c) (* y i))) t_1)))
(if (<= x -1.25e+189)
t_2
(if (<= x -1.6e+70)
(* t (- (* c j) (* x a)))
(if (<= x -6.4e+49)
(* y (+ (* x z) (/ t_1 y)))
(if (<= x -3.5e-65)
t_3
(if (<= x -8.2e-116)
(* z (- (* x y) (* b c)))
(if (<= x 3.8e+62) t_3 t_2))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = (x * y) * (z - (a * (t / y)));
double t_3 = (j * ((t * c) - (y * i))) + t_1;
double tmp;
if (x <= -1.25e+189) {
tmp = t_2;
} else if (x <= -1.6e+70) {
tmp = t * ((c * j) - (x * a));
} else if (x <= -6.4e+49) {
tmp = y * ((x * z) + (t_1 / y));
} else if (x <= -3.5e-65) {
tmp = t_3;
} else if (x <= -8.2e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 3.8e+62) {
tmp = t_3;
} 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) :: t_3
real(8) :: tmp
t_1 = a * (b * i)
t_2 = (x * y) * (z - (a * (t / y)))
t_3 = (j * ((t * c) - (y * i))) + t_1
if (x <= (-1.25d+189)) then
tmp = t_2
else if (x <= (-1.6d+70)) then
tmp = t * ((c * j) - (x * a))
else if (x <= (-6.4d+49)) then
tmp = y * ((x * z) + (t_1 / y))
else if (x <= (-3.5d-65)) then
tmp = t_3
else if (x <= (-8.2d-116)) then
tmp = z * ((x * y) - (b * c))
else if (x <= 3.8d+62) then
tmp = t_3
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = (x * y) * (z - (a * (t / y)));
double t_3 = (j * ((t * c) - (y * i))) + t_1;
double tmp;
if (x <= -1.25e+189) {
tmp = t_2;
} else if (x <= -1.6e+70) {
tmp = t * ((c * j) - (x * a));
} else if (x <= -6.4e+49) {
tmp = y * ((x * z) + (t_1 / y));
} else if (x <= -3.5e-65) {
tmp = t_3;
} else if (x <= -8.2e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 3.8e+62) {
tmp = t_3;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * (b * i) t_2 = (x * y) * (z - (a * (t / y))) t_3 = (j * ((t * c) - (y * i))) + t_1 tmp = 0 if x <= -1.25e+189: tmp = t_2 elif x <= -1.6e+70: tmp = t * ((c * j) - (x * a)) elif x <= -6.4e+49: tmp = y * ((x * z) + (t_1 / y)) elif x <= -3.5e-65: tmp = t_3 elif x <= -8.2e-116: tmp = z * ((x * y) - (b * c)) elif x <= 3.8e+62: tmp = t_3 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(b * i)) t_2 = Float64(Float64(x * y) * Float64(z - Float64(a * Float64(t / y)))) t_3 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + t_1) tmp = 0.0 if (x <= -1.25e+189) tmp = t_2; elseif (x <= -1.6e+70) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (x <= -6.4e+49) tmp = Float64(y * Float64(Float64(x * z) + Float64(t_1 / y))); elseif (x <= -3.5e-65) tmp = t_3; elseif (x <= -8.2e-116) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (x <= 3.8e+62) tmp = t_3; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); t_2 = (x * y) * (z - (a * (t / y))); t_3 = (j * ((t * c) - (y * i))) + t_1; tmp = 0.0; if (x <= -1.25e+189) tmp = t_2; elseif (x <= -1.6e+70) tmp = t * ((c * j) - (x * a)); elseif (x <= -6.4e+49) tmp = y * ((x * z) + (t_1 / y)); elseif (x <= -3.5e-65) tmp = t_3; elseif (x <= -8.2e-116) tmp = z * ((x * y) - (b * c)); elseif (x <= 3.8e+62) tmp = t_3; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] * N[(z - N[(a * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, If[LessEqual[x, -1.25e+189], t$95$2, If[LessEqual[x, -1.6e+70], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.4e+49], N[(y * N[(N[(x * z), $MachinePrecision] + N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.5e-65], t$95$3, If[LessEqual[x, -8.2e-116], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.8e+62], t$95$3, t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
t_2 := \left(x \cdot y\right) \cdot \left(z - a \cdot \frac{t}{y}\right)\\
t_3 := j \cdot \left(t \cdot c - y \cdot i\right) + t\_1\\
\mathbf{if}\;x \leq -1.25 \cdot 10^{+189}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.6 \cdot 10^{+70}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;x \leq -6.4 \cdot 10^{+49}:\\
\;\;\;\;y \cdot \left(x \cdot z + \frac{t\_1}{y}\right)\\
\mathbf{elif}\;x \leq -3.5 \cdot 10^{-65}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;x \leq -8.2 \cdot 10^{-116}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{+62}:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.2500000000000001e189 or 3.79999999999999984e62 < x Initial program 71.9%
+-commutative71.9%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
sub-neg71.9%
sub-neg71.9%
*-commutative71.9%
fma-neg73.3%
*-commutative73.3%
distribute-rgt-neg-out73.3%
remove-double-neg73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in y around -inf 62.4%
Simplified68.0%
Taylor expanded in x around inf 73.8%
associate-*r*74.7%
*-commutative74.7%
mul-1-neg74.7%
unsub-neg74.7%
associate-/l*75.1%
Simplified75.1%
if -1.2500000000000001e189 < x < -1.6000000000000001e70Initial program 54.6%
+-commutative54.6%
fma-define54.6%
*-commutative54.6%
*-commutative54.6%
cancel-sign-sub-inv54.6%
cancel-sign-sub54.6%
sub-neg54.6%
sub-neg54.6%
*-commutative54.6%
fma-neg54.6%
*-commutative54.6%
distribute-rgt-neg-out54.6%
remove-double-neg54.6%
*-commutative54.6%
*-commutative54.6%
Simplified54.6%
Taylor expanded in t around inf 63.4%
+-commutative63.4%
mul-1-neg63.4%
unsub-neg63.4%
*-commutative63.4%
Simplified63.4%
if -1.6000000000000001e70 < x < -6.40000000000000028e49Initial program 60.0%
+-commutative60.0%
fma-define60.0%
*-commutative60.0%
*-commutative60.0%
cancel-sign-sub-inv60.0%
cancel-sign-sub60.0%
sub-neg60.0%
sub-neg60.0%
*-commutative60.0%
fma-neg60.0%
*-commutative60.0%
distribute-rgt-neg-out60.0%
remove-double-neg60.0%
*-commutative60.0%
*-commutative60.0%
Simplified60.0%
Taylor expanded in y around -inf 59.4%
Simplified59.4%
Taylor expanded in i around inf 99.4%
Taylor expanded in j around 0 99.4%
if -6.40000000000000028e49 < x < -3.50000000000000005e-65 or -8.1999999999999998e-116 < x < 3.79999999999999984e62Initial program 77.7%
Taylor expanded in i around inf 66.0%
if -3.50000000000000005e-65 < x < -8.1999999999999998e-116Initial program 50.8%
Taylor expanded in c around inf 50.8%
*-commutative50.8%
associate-*l*59.7%
*-commutative59.7%
Simplified59.7%
Taylor expanded in z around inf 71.0%
*-commutative71.0%
Simplified71.0%
Final simplification69.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (* b i)))
(t_2 (* (* x y) (- z (* a (/ t y)))))
(t_3 (* j (- (* t c) (* y i)))))
(if (<= x -1.25e+189)
t_2
(if (<= x -1.35e+70)
(* t (- (* c j) (* x a)))
(if (<= x -3.9e+49)
(* y (+ (* x z) (/ t_1 y)))
(if (<= x -5.2e-58)
(+ t_3 t_1)
(if (<= x -8.2e-116)
(* z (- (* x y) (* b c)))
(if (<= x 1.05e+63) (+ t_3 (* b (* a i))) t_2))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = (x * y) * (z - (a * (t / y)));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (x <= -1.25e+189) {
tmp = t_2;
} else if (x <= -1.35e+70) {
tmp = t * ((c * j) - (x * a));
} else if (x <= -3.9e+49) {
tmp = y * ((x * z) + (t_1 / y));
} else if (x <= -5.2e-58) {
tmp = t_3 + t_1;
} else if (x <= -8.2e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 1.05e+63) {
tmp = t_3 + (b * (a * i));
} 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) :: t_3
real(8) :: tmp
t_1 = a * (b * i)
t_2 = (x * y) * (z - (a * (t / y)))
t_3 = j * ((t * c) - (y * i))
if (x <= (-1.25d+189)) then
tmp = t_2
else if (x <= (-1.35d+70)) then
tmp = t * ((c * j) - (x * a))
else if (x <= (-3.9d+49)) then
tmp = y * ((x * z) + (t_1 / y))
else if (x <= (-5.2d-58)) then
tmp = t_3 + t_1
else if (x <= (-8.2d-116)) then
tmp = z * ((x * y) - (b * c))
else if (x <= 1.05d+63) then
tmp = t_3 + (b * (a * i))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = (x * y) * (z - (a * (t / y)));
double t_3 = j * ((t * c) - (y * i));
double tmp;
if (x <= -1.25e+189) {
tmp = t_2;
} else if (x <= -1.35e+70) {
tmp = t * ((c * j) - (x * a));
} else if (x <= -3.9e+49) {
tmp = y * ((x * z) + (t_1 / y));
} else if (x <= -5.2e-58) {
tmp = t_3 + t_1;
} else if (x <= -8.2e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 1.05e+63) {
tmp = t_3 + (b * (a * i));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * (b * i) t_2 = (x * y) * (z - (a * (t / y))) t_3 = j * ((t * c) - (y * i)) tmp = 0 if x <= -1.25e+189: tmp = t_2 elif x <= -1.35e+70: tmp = t * ((c * j) - (x * a)) elif x <= -3.9e+49: tmp = y * ((x * z) + (t_1 / y)) elif x <= -5.2e-58: tmp = t_3 + t_1 elif x <= -8.2e-116: tmp = z * ((x * y) - (b * c)) elif x <= 1.05e+63: tmp = t_3 + (b * (a * i)) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(b * i)) t_2 = Float64(Float64(x * y) * Float64(z - Float64(a * Float64(t / y)))) t_3 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (x <= -1.25e+189) tmp = t_2; elseif (x <= -1.35e+70) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (x <= -3.9e+49) tmp = Float64(y * Float64(Float64(x * z) + Float64(t_1 / y))); elseif (x <= -5.2e-58) tmp = Float64(t_3 + t_1); elseif (x <= -8.2e-116) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (x <= 1.05e+63) tmp = Float64(t_3 + Float64(b * Float64(a * i))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); t_2 = (x * y) * (z - (a * (t / y))); t_3 = j * ((t * c) - (y * i)); tmp = 0.0; if (x <= -1.25e+189) tmp = t_2; elseif (x <= -1.35e+70) tmp = t * ((c * j) - (x * a)); elseif (x <= -3.9e+49) tmp = y * ((x * z) + (t_1 / y)); elseif (x <= -5.2e-58) tmp = t_3 + t_1; elseif (x <= -8.2e-116) tmp = z * ((x * y) - (b * c)); elseif (x <= 1.05e+63) tmp = t_3 + (b * (a * i)); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * y), $MachinePrecision] * N[(z - N[(a * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.25e+189], t$95$2, If[LessEqual[x, -1.35e+70], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.9e+49], N[(y * N[(N[(x * z), $MachinePrecision] + N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -5.2e-58], N[(t$95$3 + t$95$1), $MachinePrecision], If[LessEqual[x, -8.2e-116], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.05e+63], N[(t$95$3 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
t_2 := \left(x \cdot y\right) \cdot \left(z - a \cdot \frac{t}{y}\right)\\
t_3 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;x \leq -1.25 \cdot 10^{+189}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.35 \cdot 10^{+70}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;x \leq -3.9 \cdot 10^{+49}:\\
\;\;\;\;y \cdot \left(x \cdot z + \frac{t\_1}{y}\right)\\
\mathbf{elif}\;x \leq -5.2 \cdot 10^{-58}:\\
\;\;\;\;t\_3 + t\_1\\
\mathbf{elif}\;x \leq -8.2 \cdot 10^{-116}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;x \leq 1.05 \cdot 10^{+63}:\\
\;\;\;\;t\_3 + b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.2500000000000001e189 or 1.0500000000000001e63 < x Initial program 71.9%
+-commutative71.9%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
sub-neg71.9%
sub-neg71.9%
*-commutative71.9%
fma-neg73.3%
*-commutative73.3%
distribute-rgt-neg-out73.3%
remove-double-neg73.3%
*-commutative73.3%
*-commutative73.3%
Simplified73.3%
Taylor expanded in y around -inf 62.4%
Simplified68.0%
Taylor expanded in x around inf 73.8%
associate-*r*74.7%
*-commutative74.7%
mul-1-neg74.7%
unsub-neg74.7%
associate-/l*75.1%
Simplified75.1%
if -1.2500000000000001e189 < x < -1.35e70Initial program 54.6%
+-commutative54.6%
fma-define54.6%
*-commutative54.6%
*-commutative54.6%
cancel-sign-sub-inv54.6%
cancel-sign-sub54.6%
sub-neg54.6%
sub-neg54.6%
*-commutative54.6%
fma-neg54.6%
*-commutative54.6%
distribute-rgt-neg-out54.6%
remove-double-neg54.6%
*-commutative54.6%
*-commutative54.6%
Simplified54.6%
Taylor expanded in t around inf 63.4%
+-commutative63.4%
mul-1-neg63.4%
unsub-neg63.4%
*-commutative63.4%
Simplified63.4%
if -1.35e70 < x < -3.9000000000000001e49Initial program 60.0%
+-commutative60.0%
fma-define60.0%
*-commutative60.0%
*-commutative60.0%
cancel-sign-sub-inv60.0%
cancel-sign-sub60.0%
sub-neg60.0%
sub-neg60.0%
*-commutative60.0%
fma-neg60.0%
*-commutative60.0%
distribute-rgt-neg-out60.0%
remove-double-neg60.0%
*-commutative60.0%
*-commutative60.0%
Simplified60.0%
Taylor expanded in y around -inf 59.4%
Simplified59.4%
Taylor expanded in i around inf 99.4%
Taylor expanded in j around 0 99.4%
if -3.9000000000000001e49 < x < -5.20000000000000013e-58Initial program 77.2%
Taylor expanded in i around inf 73.9%
if -5.20000000000000013e-58 < x < -8.1999999999999998e-116Initial program 50.8%
Taylor expanded in c around inf 50.8%
*-commutative50.8%
associate-*l*59.7%
*-commutative59.7%
Simplified59.7%
Taylor expanded in z around inf 71.0%
*-commutative71.0%
Simplified71.0%
if -8.1999999999999998e-116 < x < 1.0500000000000001e63Initial program 77.8%
Taylor expanded in i around inf 64.3%
*-commutative64.3%
associate-*r*67.5%
Simplified67.5%
Final simplification70.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (+ (* t (- (* c j) (* x a))) (* b (- (* a i) (* z c))))))
(if (<= y -6e+116)
(* y (* i (+ (* a (/ b y)) (- (* x (/ z i)) j))))
(if (<= y -3.2e-159)
(+
(* j (- (* t c) (* y i)))
(- (* x (- (* y z) (* t a))) (* c (* z b))))
(if (<= y 1.95e-50)
t_1
(if (<= y 8.5e-12)
(- (* c (* t j)) (* i (- (* y j) (* a b))))
(if (<= y 7.5e+104)
t_1
(* y (+ (* x z) (- (/ (* a (* b i)) y) (* i j)))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
double tmp;
if (y <= -6e+116) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (y <= -3.2e-159) {
tmp = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (c * (z * b)));
} else if (y <= 1.95e-50) {
tmp = t_1;
} else if (y <= 8.5e-12) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else if (y <= 7.5e+104) {
tmp = t_1;
} else {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)))
if (y <= (-6d+116)) then
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)))
else if (y <= (-3.2d-159)) then
tmp = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (c * (z * b)))
else if (y <= 1.95d-50) then
tmp = t_1
else if (y <= 8.5d-12) then
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)))
else if (y <= 7.5d+104) then
tmp = t_1
else
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
double tmp;
if (y <= -6e+116) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (y <= -3.2e-159) {
tmp = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (c * (z * b)));
} else if (y <= 1.95e-50) {
tmp = t_1;
} else if (y <= 8.5e-12) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else if (y <= 7.5e+104) {
tmp = t_1;
} else {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))) tmp = 0 if y <= -6e+116: tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))) elif y <= -3.2e-159: tmp = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (c * (z * b))) elif y <= 1.95e-50: tmp = t_1 elif y <= 8.5e-12: tmp = (c * (t * j)) - (i * ((y * j) - (a * b))) elif y <= 7.5e+104: tmp = t_1 else: tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) tmp = 0.0 if (y <= -6e+116) tmp = Float64(y * Float64(i * Float64(Float64(a * Float64(b / y)) + Float64(Float64(x * Float64(z / i)) - j)))); elseif (y <= -3.2e-159) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(c * Float64(z * b)))); elseif (y <= 1.95e-50) tmp = t_1; elseif (y <= 8.5e-12) tmp = Float64(Float64(c * Float64(t * j)) - Float64(i * Float64(Float64(y * j) - Float64(a * b)))); elseif (y <= 7.5e+104) tmp = t_1; else tmp = Float64(y * Float64(Float64(x * z) + Float64(Float64(Float64(a * Float64(b * i)) / y) - Float64(i * j)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))); tmp = 0.0; if (y <= -6e+116) tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))); elseif (y <= -3.2e-159) tmp = (j * ((t * c) - (y * i))) + ((x * ((y * z) - (t * a))) - (c * (z * b))); elseif (y <= 1.95e-50) tmp = t_1; elseif (y <= 8.5e-12) tmp = (c * (t * j)) - (i * ((y * j) - (a * b))); elseif (y <= 7.5e+104) tmp = t_1; else tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6e+116], N[(y * N[(i * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(z / i), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -3.2e-159], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.95e-50], t$95$1, If[LessEqual[y, 8.5e-12], N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(y * j), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.5e+104], t$95$1, N[(y * N[(N[(x * z), $MachinePrecision] + N[(N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j - x \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;y \leq -6 \cdot 10^{+116}:\\
\;\;\;\;y \cdot \left(i \cdot \left(a \cdot \frac{b}{y} + \left(x \cdot \frac{z}{i} - j\right)\right)\right)\\
\mathbf{elif}\;y \leq -3.2 \cdot 10^{-159}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + \left(x \cdot \left(y \cdot z - t \cdot a\right) - c \cdot \left(z \cdot b\right)\right)\\
\mathbf{elif}\;y \leq 1.95 \cdot 10^{-50}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 8.5 \cdot 10^{-12}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) - i \cdot \left(y \cdot j - a \cdot b\right)\\
\mathbf{elif}\;y \leq 7.5 \cdot 10^{+104}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z + \left(\frac{a \cdot \left(b \cdot i\right)}{y} - i \cdot j\right)\right)\\
\end{array}
\end{array}
if y < -5.9999999999999997e116Initial program 64.1%
+-commutative64.1%
fma-define64.1%
*-commutative64.1%
*-commutative64.1%
cancel-sign-sub-inv64.1%
cancel-sign-sub64.1%
sub-neg64.1%
sub-neg64.1%
*-commutative64.1%
fma-neg64.1%
*-commutative64.1%
distribute-rgt-neg-out64.1%
remove-double-neg64.1%
*-commutative64.1%
*-commutative64.1%
Simplified64.1%
Taylor expanded in y around -inf 70.3%
Simplified74.4%
Taylor expanded in i around inf 79.1%
Taylor expanded in i around inf 81.3%
mul-1-neg81.3%
unsub-neg81.3%
associate-/l*83.3%
associate-/l*87.4%
Simplified87.4%
if -5.9999999999999997e116 < y < -3.2e-159Initial program 78.9%
Taylor expanded in c around inf 76.9%
*-commutative76.9%
associate-*l*77.0%
*-commutative77.0%
Simplified77.0%
if -3.2e-159 < y < 1.9500000000000001e-50 or 8.4999999999999997e-12 < y < 7.5000000000000002e104Initial program 80.0%
+-commutative80.0%
fma-define80.0%
*-commutative80.0%
*-commutative80.0%
cancel-sign-sub-inv80.0%
cancel-sign-sub80.0%
sub-neg80.0%
sub-neg80.0%
*-commutative80.0%
fma-neg80.0%
*-commutative80.0%
distribute-rgt-neg-out80.0%
remove-double-neg80.0%
*-commutative80.0%
*-commutative80.0%
Simplified80.0%
Taylor expanded in y around 0 79.3%
mul-1-neg79.3%
associate-*r*80.2%
*-commutative80.2%
associate-*l*83.4%
distribute-rgt-neg-in83.4%
mul-1-neg83.4%
*-commutative83.4%
*-commutative83.4%
associate-*r*82.4%
*-commutative82.4%
distribute-lft-in82.4%
+-commutative82.4%
mul-1-neg82.4%
unsub-neg82.4%
*-commutative82.4%
*-commutative82.4%
Simplified82.4%
if 1.9500000000000001e-50 < y < 8.4999999999999997e-12Initial program 41.5%
Taylor expanded in i around inf 59.9%
*-commutative59.9%
associate-*r*50.5%
Simplified50.5%
Taylor expanded in i around 0 79.7%
if 7.5000000000000002e104 < y Initial program 62.0%
+-commutative62.0%
fma-define62.0%
*-commutative62.0%
*-commutative62.0%
cancel-sign-sub-inv62.0%
cancel-sign-sub62.0%
sub-neg62.0%
sub-neg62.0%
*-commutative62.0%
fma-neg64.5%
*-commutative64.5%
distribute-rgt-neg-out64.5%
remove-double-neg64.5%
*-commutative64.5%
*-commutative64.5%
Simplified64.5%
Taylor expanded in y around -inf 71.6%
Simplified74.3%
Taylor expanded in i around inf 77.0%
Final simplification81.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))) (t_2 (* i (* a b))) (t_3 (* (- a) (* x t))))
(if (<= a -2.2e+36)
t_3
(if (<= a -6.2e-28)
t_2
(if (<= a -8e-288)
(* c (* t j))
(if (<= a 9.6e-211)
t_1
(if (<= a 1.02e-32)
(* t (* c j))
(if (<= a 5800000000000.0)
t_1
(if (<= a 2.3e+258) t_2 t_3)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double t_2 = i * (a * b);
double t_3 = -a * (x * t);
double tmp;
if (a <= -2.2e+36) {
tmp = t_3;
} else if (a <= -6.2e-28) {
tmp = t_2;
} else if (a <= -8e-288) {
tmp = c * (t * j);
} else if (a <= 9.6e-211) {
tmp = t_1;
} else if (a <= 1.02e-32) {
tmp = t * (c * j);
} else if (a <= 5800000000000.0) {
tmp = t_1;
} else if (a <= 2.3e+258) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = x * (y * z)
t_2 = i * (a * b)
t_3 = -a * (x * t)
if (a <= (-2.2d+36)) then
tmp = t_3
else if (a <= (-6.2d-28)) then
tmp = t_2
else if (a <= (-8d-288)) then
tmp = c * (t * j)
else if (a <= 9.6d-211) then
tmp = t_1
else if (a <= 1.02d-32) then
tmp = t * (c * j)
else if (a <= 5800000000000.0d0) then
tmp = t_1
else if (a <= 2.3d+258) then
tmp = t_2
else
tmp = t_3
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double t_2 = i * (a * b);
double t_3 = -a * (x * t);
double tmp;
if (a <= -2.2e+36) {
tmp = t_3;
} else if (a <= -6.2e-28) {
tmp = t_2;
} else if (a <= -8e-288) {
tmp = c * (t * j);
} else if (a <= 9.6e-211) {
tmp = t_1;
} else if (a <= 1.02e-32) {
tmp = t * (c * j);
} else if (a <= 5800000000000.0) {
tmp = t_1;
} else if (a <= 2.3e+258) {
tmp = t_2;
} else {
tmp = t_3;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) t_2 = i * (a * b) t_3 = -a * (x * t) tmp = 0 if a <= -2.2e+36: tmp = t_3 elif a <= -6.2e-28: tmp = t_2 elif a <= -8e-288: tmp = c * (t * j) elif a <= 9.6e-211: tmp = t_1 elif a <= 1.02e-32: tmp = t * (c * j) elif a <= 5800000000000.0: tmp = t_1 elif a <= 2.3e+258: tmp = t_2 else: tmp = t_3 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) t_2 = Float64(i * Float64(a * b)) t_3 = Float64(Float64(-a) * Float64(x * t)) tmp = 0.0 if (a <= -2.2e+36) tmp = t_3; elseif (a <= -6.2e-28) tmp = t_2; elseif (a <= -8e-288) tmp = Float64(c * Float64(t * j)); elseif (a <= 9.6e-211) tmp = t_1; elseif (a <= 1.02e-32) tmp = Float64(t * Float64(c * j)); elseif (a <= 5800000000000.0) tmp = t_1; elseif (a <= 2.3e+258) tmp = t_2; else tmp = t_3; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); t_2 = i * (a * b); t_3 = -a * (x * t); tmp = 0.0; if (a <= -2.2e+36) tmp = t_3; elseif (a <= -6.2e-28) tmp = t_2; elseif (a <= -8e-288) tmp = c * (t * j); elseif (a <= 9.6e-211) tmp = t_1; elseif (a <= 1.02e-32) tmp = t * (c * j); elseif (a <= 5800000000000.0) tmp = t_1; elseif (a <= 2.3e+258) tmp = t_2; else tmp = t_3; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -2.2e+36], t$95$3, If[LessEqual[a, -6.2e-28], t$95$2, If[LessEqual[a, -8e-288], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 9.6e-211], t$95$1, If[LessEqual[a, 1.02e-32], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 5800000000000.0], t$95$1, If[LessEqual[a, 2.3e+258], t$95$2, t$95$3]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
t_2 := i \cdot \left(a \cdot b\right)\\
t_3 := \left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{if}\;a \leq -2.2 \cdot 10^{+36}:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;a \leq -6.2 \cdot 10^{-28}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;a \leq -8 \cdot 10^{-288}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;a \leq 9.6 \cdot 10^{-211}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.02 \cdot 10^{-32}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;a \leq 5800000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.3 \cdot 10^{+258}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_3\\
\end{array}
\end{array}
if a < -2.2e36 or 2.3000000000000001e258 < a Initial program 54.3%
Taylor expanded in x around inf 53.0%
Taylor expanded in y around 0 55.1%
+-commutative55.1%
mul-1-neg55.1%
unsub-neg55.1%
Simplified55.1%
Taylor expanded in c around 0 55.2%
*-commutative55.2%
neg-mul-155.2%
distribute-rgt-neg-in55.2%
distribute-rgt-neg-in55.2%
Simplified55.2%
if -2.2e36 < a < -6.19999999999999984e-28 or 5.8e12 < a < 2.3000000000000001e258Initial program 68.7%
+-commutative68.7%
fma-define68.7%
*-commutative68.7%
*-commutative68.7%
cancel-sign-sub-inv68.7%
cancel-sign-sub68.7%
sub-neg68.7%
sub-neg68.7%
*-commutative68.7%
fma-neg68.7%
*-commutative68.7%
distribute-rgt-neg-out68.7%
remove-double-neg68.7%
*-commutative68.7%
*-commutative68.7%
Simplified68.7%
Taylor expanded in y around -inf 66.3%
Simplified69.3%
Taylor expanded in i around inf 57.5%
Taylor expanded in a around inf 44.5%
associate-*r*47.4%
Simplified47.4%
if -6.19999999999999984e-28 < a < -8.00000000000000046e-288Initial program 85.2%
+-commutative85.2%
fma-define85.2%
*-commutative85.2%
*-commutative85.2%
cancel-sign-sub-inv85.2%
cancel-sign-sub85.2%
sub-neg85.2%
sub-neg85.2%
*-commutative85.2%
fma-neg85.2%
*-commutative85.2%
distribute-rgt-neg-out85.2%
remove-double-neg85.2%
*-commutative85.2%
*-commutative85.2%
Simplified85.2%
Taylor expanded in c around inf 47.3%
Taylor expanded in j around inf 34.3%
if -8.00000000000000046e-288 < a < 9.6000000000000008e-211 or 1.02000000000000002e-32 < a < 5.8e12Initial program 86.5%
+-commutative86.5%
fma-define86.5%
*-commutative86.5%
*-commutative86.5%
cancel-sign-sub-inv86.5%
cancel-sign-sub86.5%
sub-neg86.5%
sub-neg86.5%
*-commutative86.5%
fma-neg86.5%
*-commutative86.5%
distribute-rgt-neg-out86.5%
remove-double-neg86.5%
*-commutative86.5%
*-commutative86.5%
Simplified86.5%
Taylor expanded in y around -inf 73.4%
Simplified76.1%
Taylor expanded in i around inf 64.8%
Taylor expanded in i around 0 48.7%
if 9.6000000000000008e-211 < a < 1.02000000000000002e-32Initial program 76.9%
+-commutative76.9%
fma-define76.9%
*-commutative76.9%
*-commutative76.9%
cancel-sign-sub-inv76.9%
cancel-sign-sub76.9%
sub-neg76.9%
sub-neg76.9%
*-commutative76.9%
fma-neg76.9%
*-commutative76.9%
distribute-rgt-neg-out76.9%
remove-double-neg76.9%
*-commutative76.9%
*-commutative76.9%
Simplified76.9%
Taylor expanded in t around inf 34.9%
+-commutative34.9%
mul-1-neg34.9%
unsub-neg34.9%
*-commutative34.9%
Simplified34.9%
Taylor expanded in j around inf 30.4%
Final simplification44.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* y (- (* x z) (* i j)))))
(if (<= y -1.8e+45)
t_1
(if (<= y -6.2e-10)
(* j (* t (- c (* x (/ a j)))))
(if (<= y -1.12e-11)
t_1
(if (<= y -3.4e-73)
(* i (- (* a b) (* y j)))
(if (<= y 7.7e-202)
(* c (* j (- t (* b (/ z j)))))
(if (<= y 3.3e+106) (+ (* c (* t j)) (* a (* b i))) t_1))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.8e+45) {
tmp = t_1;
} else if (y <= -6.2e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -1.12e-11) {
tmp = t_1;
} else if (y <= -3.4e-73) {
tmp = i * ((a * b) - (y * j));
} else if (y <= 7.7e-202) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 3.3e+106) {
tmp = (c * (t * j)) + (a * (b * i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = y * ((x * z) - (i * j))
if (y <= (-1.8d+45)) then
tmp = t_1
else if (y <= (-6.2d-10)) then
tmp = j * (t * (c - (x * (a / j))))
else if (y <= (-1.12d-11)) then
tmp = t_1
else if (y <= (-3.4d-73)) then
tmp = i * ((a * b) - (y * j))
else if (y <= 7.7d-202) then
tmp = c * (j * (t - (b * (z / j))))
else if (y <= 3.3d+106) then
tmp = (c * (t * j)) + (a * (b * i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = y * ((x * z) - (i * j));
double tmp;
if (y <= -1.8e+45) {
tmp = t_1;
} else if (y <= -6.2e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -1.12e-11) {
tmp = t_1;
} else if (y <= -3.4e-73) {
tmp = i * ((a * b) - (y * j));
} else if (y <= 7.7e-202) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 3.3e+106) {
tmp = (c * (t * j)) + (a * (b * i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = y * ((x * z) - (i * j)) tmp = 0 if y <= -1.8e+45: tmp = t_1 elif y <= -6.2e-10: tmp = j * (t * (c - (x * (a / j)))) elif y <= -1.12e-11: tmp = t_1 elif y <= -3.4e-73: tmp = i * ((a * b) - (y * j)) elif y <= 7.7e-202: tmp = c * (j * (t - (b * (z / j)))) elif y <= 3.3e+106: tmp = (c * (t * j)) + (a * (b * i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -1.8e+45) tmp = t_1; elseif (y <= -6.2e-10) tmp = Float64(j * Float64(t * Float64(c - Float64(x * Float64(a / j))))); elseif (y <= -1.12e-11) tmp = t_1; elseif (y <= -3.4e-73) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (y <= 7.7e-202) tmp = Float64(c * Float64(j * Float64(t - Float64(b * Float64(z / j))))); elseif (y <= 3.3e+106) tmp = Float64(Float64(c * Float64(t * j)) + Float64(a * Float64(b * i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -1.8e+45) tmp = t_1; elseif (y <= -6.2e-10) tmp = j * (t * (c - (x * (a / j)))); elseif (y <= -1.12e-11) tmp = t_1; elseif (y <= -3.4e-73) tmp = i * ((a * b) - (y * j)); elseif (y <= 7.7e-202) tmp = c * (j * (t - (b * (z / j)))); elseif (y <= 3.3e+106) tmp = (c * (t * j)) + (a * (b * i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.8e+45], t$95$1, If[LessEqual[y, -6.2e-10], N[(j * N[(t * N[(c - N[(x * N[(a / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.12e-11], t$95$1, If[LessEqual[y, -3.4e-73], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 7.7e-202], N[(c * N[(j * N[(t - N[(b * N[(z / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.3e+106], N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -1.8 \cdot 10^{+45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{-10}:\\
\;\;\;\;j \cdot \left(t \cdot \left(c - x \cdot \frac{a}{j}\right)\right)\\
\mathbf{elif}\;y \leq -1.12 \cdot 10^{-11}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -3.4 \cdot 10^{-73}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;y \leq 7.7 \cdot 10^{-202}:\\
\;\;\;\;c \cdot \left(j \cdot \left(t - b \cdot \frac{z}{j}\right)\right)\\
\mathbf{elif}\;y \leq 3.3 \cdot 10^{+106}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) + a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.8e45 or -6.2000000000000003e-10 < y < -1.1200000000000001e-11 or 3.30000000000000008e106 < y Initial program 64.5%
+-commutative64.5%
fma-define64.5%
*-commutative64.5%
*-commutative64.5%
cancel-sign-sub-inv64.5%
cancel-sign-sub64.5%
sub-neg64.5%
sub-neg64.5%
*-commutative64.5%
fma-neg65.5%
*-commutative65.5%
distribute-rgt-neg-out65.5%
remove-double-neg65.5%
*-commutative65.5%
*-commutative65.5%
Simplified65.5%
Taylor expanded in y around inf 67.4%
+-commutative67.4%
mul-1-neg67.4%
unsub-neg67.4%
*-commutative67.4%
Simplified67.4%
if -1.8e45 < y < -6.2000000000000003e-10Initial program 91.5%
Taylor expanded in x around inf 51.0%
Taylor expanded in y around 0 43.7%
+-commutative43.7%
mul-1-neg43.7%
unsub-neg43.7%
Simplified43.7%
Taylor expanded in j around -inf 50.9%
mul-1-neg50.9%
distribute-rgt-neg-in50.9%
+-commutative50.9%
mul-1-neg50.9%
unsub-neg50.9%
*-commutative50.9%
associate-*r*50.9%
*-commutative50.9%
associate-/l*50.9%
associate-/l*50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in j around inf 50.9%
Simplified59.5%
if -1.1200000000000001e-11 < y < -3.40000000000000021e-73Initial program 88.1%
Taylor expanded in i around inf 48.8%
*-commutative48.8%
associate-*r*54.5%
Simplified54.5%
Taylor expanded in i around inf 58.7%
+-commutative58.7%
mul-1-neg58.7%
unsub-neg58.7%
*-commutative58.7%
Simplified58.7%
if -3.40000000000000021e-73 < y < 7.6999999999999996e-202Initial program 80.5%
+-commutative80.5%
fma-define80.5%
*-commutative80.5%
*-commutative80.5%
cancel-sign-sub-inv80.5%
cancel-sign-sub80.5%
sub-neg80.5%
sub-neg80.5%
*-commutative80.5%
fma-neg80.5%
*-commutative80.5%
distribute-rgt-neg-out80.5%
remove-double-neg80.5%
*-commutative80.5%
*-commutative80.5%
Simplified80.5%
Taylor expanded in c around inf 65.0%
Taylor expanded in j around inf 66.6%
mul-1-neg66.6%
unsub-neg66.6%
associate-/l*66.6%
Simplified66.6%
if 7.6999999999999996e-202 < y < 3.30000000000000008e106Initial program 70.3%
Taylor expanded in i around inf 59.3%
*-commutative59.3%
associate-*r*54.3%
Simplified54.3%
Taylor expanded in y around 0 56.2%
Final simplification63.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (* b i))) (t_2 (* y (- (* x z) (* i j)))))
(if (<= y -3.4e+44)
t_2
(if (<= y -6.2e-10)
(* j (* t (- c (* x (/ a j)))))
(if (<= y -1.65e-15)
(* y (+ (* x z) (/ t_1 y)))
(if (<= y -2.5e-72)
(* i (- (* a b) (* y j)))
(if (<= y 4.6e-203)
(* c (* j (- t (* b (/ z j)))))
(if (<= y 4.6e+106) (+ (* c (* t j)) t_1) t_2))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -3.4e+44) {
tmp = t_2;
} else if (y <= -6.2e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -1.65e-15) {
tmp = y * ((x * z) + (t_1 / y));
} else if (y <= -2.5e-72) {
tmp = i * ((a * b) - (y * j));
} else if (y <= 4.6e-203) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 4.6e+106) {
tmp = (c * (t * j)) + t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a * (b * i)
t_2 = y * ((x * z) - (i * j))
if (y <= (-3.4d+44)) then
tmp = t_2
else if (y <= (-6.2d-10)) then
tmp = j * (t * (c - (x * (a / j))))
else if (y <= (-1.65d-15)) then
tmp = y * ((x * z) + (t_1 / y))
else if (y <= (-2.5d-72)) then
tmp = i * ((a * b) - (y * j))
else if (y <= 4.6d-203) then
tmp = c * (j * (t - (b * (z / j))))
else if (y <= 4.6d+106) then
tmp = (c * (t * j)) + t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double t_2 = y * ((x * z) - (i * j));
double tmp;
if (y <= -3.4e+44) {
tmp = t_2;
} else if (y <= -6.2e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -1.65e-15) {
tmp = y * ((x * z) + (t_1 / y));
} else if (y <= -2.5e-72) {
tmp = i * ((a * b) - (y * j));
} else if (y <= 4.6e-203) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 4.6e+106) {
tmp = (c * (t * j)) + t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * (b * i) t_2 = y * ((x * z) - (i * j)) tmp = 0 if y <= -3.4e+44: tmp = t_2 elif y <= -6.2e-10: tmp = j * (t * (c - (x * (a / j)))) elif y <= -1.65e-15: tmp = y * ((x * z) + (t_1 / y)) elif y <= -2.5e-72: tmp = i * ((a * b) - (y * j)) elif y <= 4.6e-203: tmp = c * (j * (t - (b * (z / j)))) elif y <= 4.6e+106: tmp = (c * (t * j)) + t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(b * i)) t_2 = Float64(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -3.4e+44) tmp = t_2; elseif (y <= -6.2e-10) tmp = Float64(j * Float64(t * Float64(c - Float64(x * Float64(a / j))))); elseif (y <= -1.65e-15) tmp = Float64(y * Float64(Float64(x * z) + Float64(t_1 / y))); elseif (y <= -2.5e-72) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); elseif (y <= 4.6e-203) tmp = Float64(c * Float64(j * Float64(t - Float64(b * Float64(z / j))))); elseif (y <= 4.6e+106) tmp = Float64(Float64(c * Float64(t * j)) + t_1); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); t_2 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -3.4e+44) tmp = t_2; elseif (y <= -6.2e-10) tmp = j * (t * (c - (x * (a / j)))); elseif (y <= -1.65e-15) tmp = y * ((x * z) + (t_1 / y)); elseif (y <= -2.5e-72) tmp = i * ((a * b) - (y * j)); elseif (y <= 4.6e-203) tmp = c * (j * (t - (b * (z / j)))); elseif (y <= 4.6e+106) tmp = (c * (t * j)) + t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.4e+44], t$95$2, If[LessEqual[y, -6.2e-10], N[(j * N[(t * N[(c - N[(x * N[(a / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.65e-15], N[(y * N[(N[(x * z), $MachinePrecision] + N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2.5e-72], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.6e-203], N[(c * N[(j * N[(t - N[(b * N[(z / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.6e+106], N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], t$95$2]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
t_2 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -3.4 \cdot 10^{+44}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -6.2 \cdot 10^{-10}:\\
\;\;\;\;j \cdot \left(t \cdot \left(c - x \cdot \frac{a}{j}\right)\right)\\
\mathbf{elif}\;y \leq -1.65 \cdot 10^{-15}:\\
\;\;\;\;y \cdot \left(x \cdot z + \frac{t\_1}{y}\right)\\
\mathbf{elif}\;y \leq -2.5 \cdot 10^{-72}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{-203}:\\
\;\;\;\;c \cdot \left(j \cdot \left(t - b \cdot \frac{z}{j}\right)\right)\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{+106}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -3.4e44 or 4.6000000000000004e106 < y Initial program 64.4%
+-commutative64.4%
fma-define64.4%
*-commutative64.4%
*-commutative64.4%
cancel-sign-sub-inv64.4%
cancel-sign-sub64.4%
sub-neg64.4%
sub-neg64.4%
*-commutative64.4%
fma-neg65.4%
*-commutative65.4%
distribute-rgt-neg-out65.4%
remove-double-neg65.4%
*-commutative65.4%
*-commutative65.4%
Simplified65.4%
Taylor expanded in y around inf 67.4%
+-commutative67.4%
mul-1-neg67.4%
unsub-neg67.4%
*-commutative67.4%
Simplified67.4%
if -3.4e44 < y < -6.2000000000000003e-10Initial program 91.5%
Taylor expanded in x around inf 51.0%
Taylor expanded in y around 0 43.7%
+-commutative43.7%
mul-1-neg43.7%
unsub-neg43.7%
Simplified43.7%
Taylor expanded in j around -inf 50.9%
mul-1-neg50.9%
distribute-rgt-neg-in50.9%
+-commutative50.9%
mul-1-neg50.9%
unsub-neg50.9%
*-commutative50.9%
associate-*r*50.9%
*-commutative50.9%
associate-/l*50.9%
associate-/l*50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in j around inf 50.9%
Simplified59.5%
if -6.2000000000000003e-10 < y < -1.65e-15Initial program 66.7%
+-commutative66.7%
fma-define66.7%
*-commutative66.7%
*-commutative66.7%
cancel-sign-sub-inv66.7%
cancel-sign-sub66.7%
sub-neg66.7%
sub-neg66.7%
*-commutative66.7%
fma-neg66.7%
*-commutative66.7%
distribute-rgt-neg-out66.7%
remove-double-neg66.7%
*-commutative66.7%
*-commutative66.7%
Simplified66.7%
Taylor expanded in y around -inf 66.7%
Simplified66.7%
Taylor expanded in i around inf 68.5%
Taylor expanded in j around 0 68.5%
if -1.65e-15 < y < -2.4999999999999998e-72Initial program 88.1%
Taylor expanded in i around inf 48.8%
*-commutative48.8%
associate-*r*54.5%
Simplified54.5%
Taylor expanded in i around inf 58.7%
+-commutative58.7%
mul-1-neg58.7%
unsub-neg58.7%
*-commutative58.7%
Simplified58.7%
if -2.4999999999999998e-72 < y < 4.59999999999999983e-203Initial program 80.5%
+-commutative80.5%
fma-define80.5%
*-commutative80.5%
*-commutative80.5%
cancel-sign-sub-inv80.5%
cancel-sign-sub80.5%
sub-neg80.5%
sub-neg80.5%
*-commutative80.5%
fma-neg80.5%
*-commutative80.5%
distribute-rgt-neg-out80.5%
remove-double-neg80.5%
*-commutative80.5%
*-commutative80.5%
Simplified80.5%
Taylor expanded in c around inf 65.0%
Taylor expanded in j around inf 66.6%
mul-1-neg66.6%
unsub-neg66.6%
associate-/l*66.6%
Simplified66.6%
if 4.59999999999999983e-203 < y < 4.6000000000000004e106Initial program 70.3%
Taylor expanded in i around inf 59.3%
*-commutative59.3%
associate-*r*54.3%
Simplified54.3%
Taylor expanded in y around 0 56.2%
Final simplification63.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= x -9.8e+148)
(* j (- (* t c) (* t (* a (/ x j)))))
(if (<= x -4.5e+54)
(- (* x (- (* y z) (* t a))) (* b (* z c)))
(if (<= x -4.6e-64)
(+ t_1 (* a (* b i)))
(if (<= x -3.1e-116)
(* z (- (* x y) (* b c)))
(if (<= x 7e+58)
(+ t_1 (* b (* a i)))
(* (* x y) (- z (* a (/ t y)))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (x <= -9.8e+148) {
tmp = j * ((t * c) - (t * (a * (x / j))));
} else if (x <= -4.5e+54) {
tmp = (x * ((y * z) - (t * a))) - (b * (z * c));
} else if (x <= -4.6e-64) {
tmp = t_1 + (a * (b * i));
} else if (x <= -3.1e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 7e+58) {
tmp = t_1 + (b * (a * i));
} else {
tmp = (x * y) * (z - (a * (t / y)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = j * ((t * c) - (y * i))
if (x <= (-9.8d+148)) then
tmp = j * ((t * c) - (t * (a * (x / j))))
else if (x <= (-4.5d+54)) then
tmp = (x * ((y * z) - (t * a))) - (b * (z * c))
else if (x <= (-4.6d-64)) then
tmp = t_1 + (a * (b * i))
else if (x <= (-3.1d-116)) then
tmp = z * ((x * y) - (b * c))
else if (x <= 7d+58) then
tmp = t_1 + (b * (a * i))
else
tmp = (x * y) * (z - (a * (t / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (x <= -9.8e+148) {
tmp = j * ((t * c) - (t * (a * (x / j))));
} else if (x <= -4.5e+54) {
tmp = (x * ((y * z) - (t * a))) - (b * (z * c));
} else if (x <= -4.6e-64) {
tmp = t_1 + (a * (b * i));
} else if (x <= -3.1e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 7e+58) {
tmp = t_1 + (b * (a * i));
} else {
tmp = (x * y) * (z - (a * (t / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) tmp = 0 if x <= -9.8e+148: tmp = j * ((t * c) - (t * (a * (x / j)))) elif x <= -4.5e+54: tmp = (x * ((y * z) - (t * a))) - (b * (z * c)) elif x <= -4.6e-64: tmp = t_1 + (a * (b * i)) elif x <= -3.1e-116: tmp = z * ((x * y) - (b * c)) elif x <= 7e+58: tmp = t_1 + (b * (a * i)) else: tmp = (x * y) * (z - (a * (t / y))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (x <= -9.8e+148) tmp = Float64(j * Float64(Float64(t * c) - Float64(t * Float64(a * Float64(x / j))))); elseif (x <= -4.5e+54) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(z * c))); elseif (x <= -4.6e-64) tmp = Float64(t_1 + Float64(a * Float64(b * i))); elseif (x <= -3.1e-116) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (x <= 7e+58) tmp = Float64(t_1 + Float64(b * Float64(a * i))); else tmp = Float64(Float64(x * y) * Float64(z - Float64(a * Float64(t / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((t * c) - (y * i)); tmp = 0.0; if (x <= -9.8e+148) tmp = j * ((t * c) - (t * (a * (x / j)))); elseif (x <= -4.5e+54) tmp = (x * ((y * z) - (t * a))) - (b * (z * c)); elseif (x <= -4.6e-64) tmp = t_1 + (a * (b * i)); elseif (x <= -3.1e-116) tmp = z * ((x * y) - (b * c)); elseif (x <= 7e+58) tmp = t_1 + (b * (a * i)); else tmp = (x * y) * (z - (a * (t / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -9.8e+148], N[(j * N[(N[(t * c), $MachinePrecision] - N[(t * N[(a * N[(x / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.5e+54], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -4.6e-64], N[(t$95$1 + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -3.1e-116], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 7e+58], N[(t$95$1 + N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(z - N[(a * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;x \leq -9.8 \cdot 10^{+148}:\\
\;\;\;\;j \cdot \left(t \cdot c - t \cdot \left(a \cdot \frac{x}{j}\right)\right)\\
\mathbf{elif}\;x \leq -4.5 \cdot 10^{+54}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(z \cdot c\right)\\
\mathbf{elif}\;x \leq -4.6 \cdot 10^{-64}:\\
\;\;\;\;t\_1 + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;x \leq -3.1 \cdot 10^{-116}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;x \leq 7 \cdot 10^{+58}:\\
\;\;\;\;t\_1 + b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \left(z - a \cdot \frac{t}{y}\right)\\
\end{array}
\end{array}
if x < -9.8e148Initial program 64.1%
Taylor expanded in x around inf 72.1%
Taylor expanded in y around 0 49.4%
+-commutative49.4%
mul-1-neg49.4%
unsub-neg49.4%
Simplified49.4%
Taylor expanded in j around -inf 64.3%
mul-1-neg64.3%
distribute-rgt-neg-in64.3%
+-commutative64.3%
mul-1-neg64.3%
unsub-neg64.3%
*-commutative64.3%
associate-*r*68.3%
*-commutative68.3%
associate-/l*72.2%
associate-/l*76.1%
*-commutative76.1%
Simplified76.1%
if -9.8e148 < x < -4.49999999999999984e54Initial program 59.6%
Taylor expanded in c around inf 64.1%
*-commutative64.1%
associate-*l*64.2%
*-commutative64.2%
Simplified64.2%
Taylor expanded in j around 0 68.1%
*-commutative68.1%
*-commutative68.1%
*-commutative68.1%
*-commutative68.1%
Simplified68.1%
if -4.49999999999999984e54 < x < -4.6000000000000003e-64Initial program 78.1%
Taylor expanded in i around inf 73.0%
if -4.6000000000000003e-64 < x < -3.10000000000000018e-116Initial program 50.8%
Taylor expanded in c around inf 50.8%
*-commutative50.8%
associate-*l*59.7%
*-commutative59.7%
Simplified59.7%
Taylor expanded in z around inf 71.0%
*-commutative71.0%
Simplified71.0%
if -3.10000000000000018e-116 < x < 6.9999999999999995e58Initial program 77.8%
Taylor expanded in i around inf 64.3%
*-commutative64.3%
associate-*r*67.5%
Simplified67.5%
if 6.9999999999999995e58 < x Initial program 71.2%
+-commutative71.2%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
sub-neg71.2%
sub-neg71.2%
*-commutative71.2%
fma-neg73.1%
*-commutative73.1%
distribute-rgt-neg-out73.1%
remove-double-neg73.1%
*-commutative73.1%
*-commutative73.1%
Simplified73.1%
Taylor expanded in y around -inf 62.2%
Simplified67.9%
Taylor expanded in x around inf 73.6%
associate-*r*75.2%
*-commutative75.2%
mul-1-neg75.2%
unsub-neg75.2%
associate-/l*73.4%
Simplified73.4%
Final simplification70.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -1.1e+149)
(* j (- (* t c) (* t (* a (/ x j)))))
(if (<= x -1.8e+54)
(- (* x (- (* y z) (* t a))) (* b (* z c)))
(if (<= x -7e-63)
(+ (* j (- (* t c) (* y i))) (* a (* b i)))
(if (<= x -7.8e-116)
(* z (- (* x y) (* b c)))
(if (<= x 3.8e+61)
(- (* c (* t j)) (* i (- (* y j) (* a b))))
(* (* x y) (- z (* a (/ t y))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.1e+149) {
tmp = j * ((t * c) - (t * (a * (x / j))));
} else if (x <= -1.8e+54) {
tmp = (x * ((y * z) - (t * a))) - (b * (z * c));
} else if (x <= -7e-63) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else if (x <= -7.8e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 3.8e+61) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else {
tmp = (x * y) * (z - (a * (t / y)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-1.1d+149)) then
tmp = j * ((t * c) - (t * (a * (x / j))))
else if (x <= (-1.8d+54)) then
tmp = (x * ((y * z) - (t * a))) - (b * (z * c))
else if (x <= (-7d-63)) then
tmp = (j * ((t * c) - (y * i))) + (a * (b * i))
else if (x <= (-7.8d-116)) then
tmp = z * ((x * y) - (b * c))
else if (x <= 3.8d+61) then
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)))
else
tmp = (x * y) * (z - (a * (t / y)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.1e+149) {
tmp = j * ((t * c) - (t * (a * (x / j))));
} else if (x <= -1.8e+54) {
tmp = (x * ((y * z) - (t * a))) - (b * (z * c));
} else if (x <= -7e-63) {
tmp = (j * ((t * c) - (y * i))) + (a * (b * i));
} else if (x <= -7.8e-116) {
tmp = z * ((x * y) - (b * c));
} else if (x <= 3.8e+61) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else {
tmp = (x * y) * (z - (a * (t / y)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -1.1e+149: tmp = j * ((t * c) - (t * (a * (x / j)))) elif x <= -1.8e+54: tmp = (x * ((y * z) - (t * a))) - (b * (z * c)) elif x <= -7e-63: tmp = (j * ((t * c) - (y * i))) + (a * (b * i)) elif x <= -7.8e-116: tmp = z * ((x * y) - (b * c)) elif x <= 3.8e+61: tmp = (c * (t * j)) - (i * ((y * j) - (a * b))) else: tmp = (x * y) * (z - (a * (t / y))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -1.1e+149) tmp = Float64(j * Float64(Float64(t * c) - Float64(t * Float64(a * Float64(x / j))))); elseif (x <= -1.8e+54) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(z * c))); elseif (x <= -7e-63) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(a * Float64(b * i))); elseif (x <= -7.8e-116) tmp = Float64(z * Float64(Float64(x * y) - Float64(b * c))); elseif (x <= 3.8e+61) tmp = Float64(Float64(c * Float64(t * j)) - Float64(i * Float64(Float64(y * j) - Float64(a * b)))); else tmp = Float64(Float64(x * y) * Float64(z - Float64(a * Float64(t / y)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -1.1e+149) tmp = j * ((t * c) - (t * (a * (x / j)))); elseif (x <= -1.8e+54) tmp = (x * ((y * z) - (t * a))) - (b * (z * c)); elseif (x <= -7e-63) tmp = (j * ((t * c) - (y * i))) + (a * (b * i)); elseif (x <= -7.8e-116) tmp = z * ((x * y) - (b * c)); elseif (x <= 3.8e+61) tmp = (c * (t * j)) - (i * ((y * j) - (a * b))); else tmp = (x * y) * (z - (a * (t / y))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -1.1e+149], N[(j * N[(N[(t * c), $MachinePrecision] - N[(t * N[(a * N[(x / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.8e+54], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7e-63], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -7.8e-116], N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.8e+61], N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(y * j), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * N[(z - N[(a * N[(t / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.1 \cdot 10^{+149}:\\
\;\;\;\;j \cdot \left(t \cdot c - t \cdot \left(a \cdot \frac{x}{j}\right)\right)\\
\mathbf{elif}\;x \leq -1.8 \cdot 10^{+54}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(z \cdot c\right)\\
\mathbf{elif}\;x \leq -7 \cdot 10^{-63}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + a \cdot \left(b \cdot i\right)\\
\mathbf{elif}\;x \leq -7.8 \cdot 10^{-116}:\\
\;\;\;\;z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;x \leq 3.8 \cdot 10^{+61}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) - i \cdot \left(y \cdot j - a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(x \cdot y\right) \cdot \left(z - a \cdot \frac{t}{y}\right)\\
\end{array}
\end{array}
if x < -1.1e149Initial program 64.1%
Taylor expanded in x around inf 72.1%
Taylor expanded in y around 0 49.4%
+-commutative49.4%
mul-1-neg49.4%
unsub-neg49.4%
Simplified49.4%
Taylor expanded in j around -inf 64.3%
mul-1-neg64.3%
distribute-rgt-neg-in64.3%
+-commutative64.3%
mul-1-neg64.3%
unsub-neg64.3%
*-commutative64.3%
associate-*r*68.3%
*-commutative68.3%
associate-/l*72.2%
associate-/l*76.1%
*-commutative76.1%
Simplified76.1%
if -1.1e149 < x < -1.8000000000000001e54Initial program 59.6%
Taylor expanded in c around inf 64.1%
*-commutative64.1%
associate-*l*64.2%
*-commutative64.2%
Simplified64.2%
Taylor expanded in j around 0 68.1%
*-commutative68.1%
*-commutative68.1%
*-commutative68.1%
*-commutative68.1%
Simplified68.1%
if -1.8000000000000001e54 < x < -7.00000000000000006e-63Initial program 78.1%
Taylor expanded in i around inf 73.0%
if -7.00000000000000006e-63 < x < -7.8000000000000001e-116Initial program 50.8%
Taylor expanded in c around inf 50.8%
*-commutative50.8%
associate-*l*59.7%
*-commutative59.7%
Simplified59.7%
Taylor expanded in z around inf 71.0%
*-commutative71.0%
Simplified71.0%
if -7.8000000000000001e-116 < x < 3.79999999999999995e61Initial program 77.8%
Taylor expanded in i around inf 64.3%
*-commutative64.3%
associate-*r*67.5%
Simplified67.5%
Taylor expanded in i around 0 70.7%
if 3.79999999999999995e61 < x Initial program 71.2%
+-commutative71.2%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
sub-neg71.2%
sub-neg71.2%
*-commutative71.2%
fma-neg73.1%
*-commutative73.1%
distribute-rgt-neg-out73.1%
remove-double-neg73.1%
*-commutative73.1%
*-commutative73.1%
Simplified73.1%
Taylor expanded in y around -inf 62.2%
Simplified67.9%
Taylor expanded in x around inf 73.6%
associate-*r*75.2%
*-commutative75.2%
mul-1-neg75.2%
unsub-neg75.2%
associate-/l*73.4%
Simplified73.4%
Final simplification71.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))))
(if (<= x -2.9e-10)
(* t (- (* c j) (* x a)))
(if (<= x 4.35e-228)
t_1
(if (<= x 7.6e-118)
(* j (- (* t c) (* y i)))
(if (<= x 3.2e-74)
t_1
(if (<= x 9e-48)
(* c (- (* t j) (* z b)))
(if (<= x 1e+95) t_1 (* x (- (* y z) (* t a)))))))))))
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 tmp;
if (x <= -2.9e-10) {
tmp = t * ((c * j) - (x * a));
} else if (x <= 4.35e-228) {
tmp = t_1;
} else if (x <= 7.6e-118) {
tmp = j * ((t * c) - (y * i));
} else if (x <= 3.2e-74) {
tmp = t_1;
} else if (x <= 9e-48) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 1e+95) {
tmp = t_1;
} else {
tmp = x * ((y * z) - (t * a));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = i * ((a * b) - (y * j))
if (x <= (-2.9d-10)) then
tmp = t * ((c * j) - (x * a))
else if (x <= 4.35d-228) then
tmp = t_1
else if (x <= 7.6d-118) then
tmp = j * ((t * c) - (y * i))
else if (x <= 3.2d-74) then
tmp = t_1
else if (x <= 9d-48) then
tmp = c * ((t * j) - (z * b))
else if (x <= 1d+95) then
tmp = t_1
else
tmp = x * ((y * z) - (t * a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * ((a * b) - (y * j));
double tmp;
if (x <= -2.9e-10) {
tmp = t * ((c * j) - (x * a));
} else if (x <= 4.35e-228) {
tmp = t_1;
} else if (x <= 7.6e-118) {
tmp = j * ((t * c) - (y * i));
} else if (x <= 3.2e-74) {
tmp = t_1;
} else if (x <= 9e-48) {
tmp = c * ((t * j) - (z * b));
} else if (x <= 1e+95) {
tmp = t_1;
} else {
tmp = x * ((y * z) - (t * a));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * ((a * b) - (y * j)) tmp = 0 if x <= -2.9e-10: tmp = t * ((c * j) - (x * a)) elif x <= 4.35e-228: tmp = t_1 elif x <= 7.6e-118: tmp = j * ((t * c) - (y * i)) elif x <= 3.2e-74: tmp = t_1 elif x <= 9e-48: tmp = c * ((t * j) - (z * b)) elif x <= 1e+95: tmp = t_1 else: tmp = x * ((y * z) - (t * a)) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (x <= -2.9e-10) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (x <= 4.35e-228) tmp = t_1; elseif (x <= 7.6e-118) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (x <= 3.2e-74) tmp = t_1; elseif (x <= 9e-48) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (x <= 1e+95) tmp = t_1; else tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * ((a * b) - (y * j)); tmp = 0.0; if (x <= -2.9e-10) tmp = t * ((c * j) - (x * a)); elseif (x <= 4.35e-228) tmp = t_1; elseif (x <= 7.6e-118) tmp = j * ((t * c) - (y * i)); elseif (x <= 3.2e-74) tmp = t_1; elseif (x <= 9e-48) tmp = c * ((t * j) - (z * b)); elseif (x <= 1e+95) tmp = t_1; else tmp = x * ((y * z) - (t * a)); 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]}, If[LessEqual[x, -2.9e-10], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.35e-228], t$95$1, If[LessEqual[x, 7.6e-118], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.2e-74], t$95$1, If[LessEqual[x, 9e-48], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1e+95], t$95$1, N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;x \leq -2.9 \cdot 10^{-10}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;x \leq 4.35 \cdot 10^{-228}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 7.6 \cdot 10^{-118}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 9 \cdot 10^{-48}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;x \leq 10^{+95}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\end{array}
\end{array}
if x < -2.89999999999999981e-10Initial program 67.9%
+-commutative67.9%
fma-define67.9%
*-commutative67.9%
*-commutative67.9%
cancel-sign-sub-inv67.9%
cancel-sign-sub67.9%
sub-neg67.9%
sub-neg67.9%
*-commutative67.9%
fma-neg67.9%
*-commutative67.9%
distribute-rgt-neg-out67.9%
remove-double-neg67.9%
*-commutative67.9%
*-commutative67.9%
Simplified67.9%
Taylor expanded in t around inf 56.9%
+-commutative56.9%
mul-1-neg56.9%
unsub-neg56.9%
*-commutative56.9%
Simplified56.9%
if -2.89999999999999981e-10 < x < 4.3500000000000002e-228 or 7.6000000000000002e-118 < x < 3.1999999999999999e-74 or 8.99999999999999977e-48 < x < 1.00000000000000002e95Initial program 76.0%
Taylor expanded in i around inf 59.5%
*-commutative59.5%
associate-*r*63.1%
Simplified63.1%
Taylor expanded in i around inf 60.7%
+-commutative60.7%
mul-1-neg60.7%
unsub-neg60.7%
*-commutative60.7%
Simplified60.7%
if 4.3500000000000002e-228 < x < 7.6000000000000002e-118Initial program 71.4%
Taylor expanded in i around inf 77.0%
*-commutative77.0%
associate-*r*72.2%
Simplified72.2%
Taylor expanded in b around 0 67.5%
if 3.1999999999999999e-74 < x < 8.99999999999999977e-48Initial program 73.6%
+-commutative73.6%
fma-define73.6%
*-commutative73.6%
*-commutative73.6%
cancel-sign-sub-inv73.6%
cancel-sign-sub73.6%
sub-neg73.6%
sub-neg73.6%
*-commutative73.6%
fma-neg73.6%
*-commutative73.6%
distribute-rgt-neg-out73.6%
remove-double-neg73.6%
*-commutative73.6%
*-commutative73.6%
Simplified73.6%
Taylor expanded in c around inf 64.7%
if 1.00000000000000002e95 < x Initial program 71.1%
Taylor expanded in x around inf 69.1%
Taylor expanded in x around inf 73.9%
Final simplification62.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* y (- (* x z) (* i j)))))
(if (<= y -4.4e+35)
t_2
(if (<= y -5.6e-10)
(* t (- (* c j) (* x a)))
(if (<= y -1.1e-11)
t_2
(if (<= y -9.5e-73)
t_1
(if (<= y 3.2e-30)
(* c (- (* t j) (* z b)))
(if (<= y 8.4e+108) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.4e+35) {
tmp = t_2;
} else if (y <= -5.6e-10) {
tmp = t * ((c * j) - (x * a));
} else if (y <= -1.1e-11) {
tmp = t_2;
} else if (y <= -9.5e-73) {
tmp = t_1;
} else if (y <= 3.2e-30) {
tmp = c * ((t * j) - (z * b));
} else if (y <= 8.4e+108) {
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 = y * ((x * z) - (i * j))
if (y <= (-4.4d+35)) then
tmp = t_2
else if (y <= (-5.6d-10)) then
tmp = t * ((c * j) - (x * a))
else if (y <= (-1.1d-11)) then
tmp = t_2
else if (y <= (-9.5d-73)) then
tmp = t_1
else if (y <= 3.2d-30) then
tmp = c * ((t * j) - (z * b))
else if (y <= 8.4d+108) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.4e+35) {
tmp = t_2;
} else if (y <= -5.6e-10) {
tmp = t * ((c * j) - (x * a));
} else if (y <= -1.1e-11) {
tmp = t_2;
} else if (y <= -9.5e-73) {
tmp = t_1;
} else if (y <= 3.2e-30) {
tmp = c * ((t * j) - (z * b));
} else if (y <= 8.4e+108) {
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 = y * ((x * z) - (i * j)) tmp = 0 if y <= -4.4e+35: tmp = t_2 elif y <= -5.6e-10: tmp = t * ((c * j) - (x * a)) elif y <= -1.1e-11: tmp = t_2 elif y <= -9.5e-73: tmp = t_1 elif y <= 3.2e-30: tmp = c * ((t * j) - (z * b)) elif y <= 8.4e+108: 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(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -4.4e+35) tmp = t_2; elseif (y <= -5.6e-10) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (y <= -1.1e-11) tmp = t_2; elseif (y <= -9.5e-73) tmp = t_1; elseif (y <= 3.2e-30) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (y <= 8.4e+108) 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 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -4.4e+35) tmp = t_2; elseif (y <= -5.6e-10) tmp = t * ((c * j) - (x * a)); elseif (y <= -1.1e-11) tmp = t_2; elseif (y <= -9.5e-73) tmp = t_1; elseif (y <= 3.2e-30) tmp = c * ((t * j) - (z * b)); elseif (y <= 8.4e+108) 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[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.4e+35], t$95$2, If[LessEqual[y, -5.6e-10], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.1e-11], t$95$2, If[LessEqual[y, -9.5e-73], t$95$1, If[LessEqual[y, 3.2e-30], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.4e+108], 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 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -4.4 \cdot 10^{+35}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -5.6 \cdot 10^{-10}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;y \leq -1.1 \cdot 10^{-11}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -9.5 \cdot 10^{-73}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{-30}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;y \leq 8.4 \cdot 10^{+108}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -4.3999999999999997e35 or -5.60000000000000031e-10 < y < -1.1000000000000001e-11 or 8.40000000000000039e108 < y Initial program 66.1%
+-commutative66.1%
fma-define66.1%
*-commutative66.1%
*-commutative66.1%
cancel-sign-sub-inv66.1%
cancel-sign-sub66.1%
sub-neg66.1%
sub-neg66.1%
*-commutative66.1%
fma-neg67.0%
*-commutative67.0%
distribute-rgt-neg-out67.0%
remove-double-neg67.0%
*-commutative67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in y around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
if -4.3999999999999997e35 < y < -5.60000000000000031e-10Initial program 88.9%
+-commutative88.9%
fma-define88.9%
*-commutative88.9%
*-commutative88.9%
cancel-sign-sub-inv88.9%
cancel-sign-sub88.9%
sub-neg88.9%
sub-neg88.9%
*-commutative88.9%
fma-neg88.9%
*-commutative88.9%
distribute-rgt-neg-out88.9%
remove-double-neg88.9%
*-commutative88.9%
*-commutative88.9%
Simplified88.9%
Taylor expanded in t around inf 67.6%
+-commutative67.6%
mul-1-neg67.6%
unsub-neg67.6%
*-commutative67.6%
Simplified67.6%
if -1.1000000000000001e-11 < y < -9.50000000000000005e-73 or 3.2e-30 < y < 8.40000000000000039e108Initial program 72.0%
Taylor expanded in i around inf 56.9%
*-commutative56.9%
associate-*r*56.8%
Simplified56.8%
Taylor expanded in i around inf 62.2%
+-commutative62.2%
mul-1-neg62.2%
unsub-neg62.2%
*-commutative62.2%
Simplified62.2%
if -9.50000000000000005e-73 < y < 3.2e-30Initial program 79.0%
+-commutative79.0%
fma-define79.0%
*-commutative79.0%
*-commutative79.0%
cancel-sign-sub-inv79.0%
cancel-sign-sub79.0%
sub-neg79.0%
sub-neg79.0%
*-commutative79.0%
fma-neg79.0%
*-commutative79.0%
distribute-rgt-neg-out79.0%
remove-double-neg79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
Taylor expanded in c around inf 57.9%
Final simplification63.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* y (- (* x z) (* i j)))))
(if (<= y -2.6e+35)
t_2
(if (<= y -5.6e-10)
(* t (- (* c j) (* x a)))
(if (<= y -8.8e-15)
t_2
(if (<= y -2.3e-72)
t_1
(if (<= y 9.2e-26)
(* c (* j (- t (* b (/ z j)))))
(if (<= y 2.1e+107) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -2.6e+35) {
tmp = t_2;
} else if (y <= -5.6e-10) {
tmp = t * ((c * j) - (x * a));
} else if (y <= -8.8e-15) {
tmp = t_2;
} else if (y <= -2.3e-72) {
tmp = t_1;
} else if (y <= 9.2e-26) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 2.1e+107) {
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 = y * ((x * z) - (i * j))
if (y <= (-2.6d+35)) then
tmp = t_2
else if (y <= (-5.6d-10)) then
tmp = t * ((c * j) - (x * a))
else if (y <= (-8.8d-15)) then
tmp = t_2
else if (y <= (-2.3d-72)) then
tmp = t_1
else if (y <= 9.2d-26) then
tmp = c * (j * (t - (b * (z / j))))
else if (y <= 2.1d+107) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -2.6e+35) {
tmp = t_2;
} else if (y <= -5.6e-10) {
tmp = t * ((c * j) - (x * a));
} else if (y <= -8.8e-15) {
tmp = t_2;
} else if (y <= -2.3e-72) {
tmp = t_1;
} else if (y <= 9.2e-26) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 2.1e+107) {
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 = y * ((x * z) - (i * j)) tmp = 0 if y <= -2.6e+35: tmp = t_2 elif y <= -5.6e-10: tmp = t * ((c * j) - (x * a)) elif y <= -8.8e-15: tmp = t_2 elif y <= -2.3e-72: tmp = t_1 elif y <= 9.2e-26: tmp = c * (j * (t - (b * (z / j)))) elif y <= 2.1e+107: 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(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -2.6e+35) tmp = t_2; elseif (y <= -5.6e-10) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); elseif (y <= -8.8e-15) tmp = t_2; elseif (y <= -2.3e-72) tmp = t_1; elseif (y <= 9.2e-26) tmp = Float64(c * Float64(j * Float64(t - Float64(b * Float64(z / j))))); elseif (y <= 2.1e+107) 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 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -2.6e+35) tmp = t_2; elseif (y <= -5.6e-10) tmp = t * ((c * j) - (x * a)); elseif (y <= -8.8e-15) tmp = t_2; elseif (y <= -2.3e-72) tmp = t_1; elseif (y <= 9.2e-26) tmp = c * (j * (t - (b * (z / j)))); elseif (y <= 2.1e+107) 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[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -2.6e+35], t$95$2, If[LessEqual[y, -5.6e-10], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -8.8e-15], t$95$2, If[LessEqual[y, -2.3e-72], t$95$1, If[LessEqual[y, 9.2e-26], N[(c * N[(j * N[(t - N[(b * N[(z / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.1e+107], 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 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -2.6 \cdot 10^{+35}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -5.6 \cdot 10^{-10}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{elif}\;y \leq -8.8 \cdot 10^{-15}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -2.3 \cdot 10^{-72}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 9.2 \cdot 10^{-26}:\\
\;\;\;\;c \cdot \left(j \cdot \left(t - b \cdot \frac{z}{j}\right)\right)\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+107}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -2.60000000000000007e35 or -5.60000000000000031e-10 < y < -8.79999999999999942e-15 or 2.1e107 < y Initial program 66.1%
+-commutative66.1%
fma-define66.1%
*-commutative66.1%
*-commutative66.1%
cancel-sign-sub-inv66.1%
cancel-sign-sub66.1%
sub-neg66.1%
sub-neg66.1%
*-commutative66.1%
fma-neg67.0%
*-commutative67.0%
distribute-rgt-neg-out67.0%
remove-double-neg67.0%
*-commutative67.0%
*-commutative67.0%
Simplified67.0%
Taylor expanded in y around inf 67.1%
+-commutative67.1%
mul-1-neg67.1%
unsub-neg67.1%
*-commutative67.1%
Simplified67.1%
if -2.60000000000000007e35 < y < -5.60000000000000031e-10Initial program 88.9%
+-commutative88.9%
fma-define88.9%
*-commutative88.9%
*-commutative88.9%
cancel-sign-sub-inv88.9%
cancel-sign-sub88.9%
sub-neg88.9%
sub-neg88.9%
*-commutative88.9%
fma-neg88.9%
*-commutative88.9%
distribute-rgt-neg-out88.9%
remove-double-neg88.9%
*-commutative88.9%
*-commutative88.9%
Simplified88.9%
Taylor expanded in t around inf 67.6%
+-commutative67.6%
mul-1-neg67.6%
unsub-neg67.6%
*-commutative67.6%
Simplified67.6%
if -8.79999999999999942e-15 < y < -2.29999999999999995e-72 or 9.20000000000000035e-26 < y < 2.1e107Initial program 72.0%
Taylor expanded in i around inf 56.9%
*-commutative56.9%
associate-*r*56.8%
Simplified56.8%
Taylor expanded in i around inf 62.2%
+-commutative62.2%
mul-1-neg62.2%
unsub-neg62.2%
*-commutative62.2%
Simplified62.2%
if -2.29999999999999995e-72 < y < 9.20000000000000035e-26Initial program 79.0%
+-commutative79.0%
fma-define79.0%
*-commutative79.0%
*-commutative79.0%
cancel-sign-sub-inv79.0%
cancel-sign-sub79.0%
sub-neg79.0%
sub-neg79.0%
*-commutative79.0%
fma-neg79.0%
*-commutative79.0%
distribute-rgt-neg-out79.0%
remove-double-neg79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
Taylor expanded in c around inf 57.9%
Taylor expanded in j around inf 59.0%
mul-1-neg59.0%
unsub-neg59.0%
associate-/l*59.0%
Simplified59.0%
Final simplification63.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* y (- (* x z) (* i j)))))
(if (<= y -4.3e+47)
t_2
(if (<= y -6e-10)
(* j (* t (- c (* x (/ a j)))))
(if (<= y -2e-11)
t_2
(if (<= y -7e-74)
t_1
(if (<= y 4.7e-26)
(* c (* j (- t (* b (/ z j)))))
(if (<= y 4.5e+108) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.3e+47) {
tmp = t_2;
} else if (y <= -6e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -2e-11) {
tmp = t_2;
} else if (y <= -7e-74) {
tmp = t_1;
} else if (y <= 4.7e-26) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 4.5e+108) {
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 = y * ((x * z) - (i * j))
if (y <= (-4.3d+47)) then
tmp = t_2
else if (y <= (-6d-10)) then
tmp = j * (t * (c - (x * (a / j))))
else if (y <= (-2d-11)) then
tmp = t_2
else if (y <= (-7d-74)) then
tmp = t_1
else if (y <= 4.7d-26) then
tmp = c * (j * (t - (b * (z / j))))
else if (y <= 4.5d+108) 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 = y * ((x * z) - (i * j));
double tmp;
if (y <= -4.3e+47) {
tmp = t_2;
} else if (y <= -6e-10) {
tmp = j * (t * (c - (x * (a / j))));
} else if (y <= -2e-11) {
tmp = t_2;
} else if (y <= -7e-74) {
tmp = t_1;
} else if (y <= 4.7e-26) {
tmp = c * (j * (t - (b * (z / j))));
} else if (y <= 4.5e+108) {
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 = y * ((x * z) - (i * j)) tmp = 0 if y <= -4.3e+47: tmp = t_2 elif y <= -6e-10: tmp = j * (t * (c - (x * (a / j)))) elif y <= -2e-11: tmp = t_2 elif y <= -7e-74: tmp = t_1 elif y <= 4.7e-26: tmp = c * (j * (t - (b * (z / j)))) elif y <= 4.5e+108: 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(y * Float64(Float64(x * z) - Float64(i * j))) tmp = 0.0 if (y <= -4.3e+47) tmp = t_2; elseif (y <= -6e-10) tmp = Float64(j * Float64(t * Float64(c - Float64(x * Float64(a / j))))); elseif (y <= -2e-11) tmp = t_2; elseif (y <= -7e-74) tmp = t_1; elseif (y <= 4.7e-26) tmp = Float64(c * Float64(j * Float64(t - Float64(b * Float64(z / j))))); elseif (y <= 4.5e+108) 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 = y * ((x * z) - (i * j)); tmp = 0.0; if (y <= -4.3e+47) tmp = t_2; elseif (y <= -6e-10) tmp = j * (t * (c - (x * (a / j)))); elseif (y <= -2e-11) tmp = t_2; elseif (y <= -7e-74) tmp = t_1; elseif (y <= 4.7e-26) tmp = c * (j * (t - (b * (z / j)))); elseif (y <= 4.5e+108) 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[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4.3e+47], t$95$2, If[LessEqual[y, -6e-10], N[(j * N[(t * N[(c - N[(x * N[(a / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -2e-11], t$95$2, If[LessEqual[y, -7e-74], t$95$1, If[LessEqual[y, 4.7e-26], N[(c * N[(j * N[(t - N[(b * N[(z / j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.5e+108], 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 := y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{if}\;y \leq -4.3 \cdot 10^{+47}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -6 \cdot 10^{-10}:\\
\;\;\;\;j \cdot \left(t \cdot \left(c - x \cdot \frac{a}{j}\right)\right)\\
\mathbf{elif}\;y \leq -2 \cdot 10^{-11}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -7 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 4.7 \cdot 10^{-26}:\\
\;\;\;\;c \cdot \left(j \cdot \left(t - b \cdot \frac{z}{j}\right)\right)\\
\mathbf{elif}\;y \leq 4.5 \cdot 10^{+108}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -4.29999999999999995e47 or -6e-10 < y < -1.99999999999999988e-11 or 4.5e108 < y Initial program 65.1%
+-commutative65.1%
fma-define65.1%
*-commutative65.1%
*-commutative65.1%
cancel-sign-sub-inv65.1%
cancel-sign-sub65.1%
sub-neg65.1%
sub-neg65.1%
*-commutative65.1%
fma-neg66.1%
*-commutative66.1%
distribute-rgt-neg-out66.1%
remove-double-neg66.1%
*-commutative66.1%
*-commutative66.1%
Simplified66.1%
Taylor expanded in y around inf 68.0%
+-commutative68.0%
mul-1-neg68.0%
unsub-neg68.0%
*-commutative68.0%
Simplified68.0%
if -4.29999999999999995e47 < y < -6e-10Initial program 91.5%
Taylor expanded in x around inf 51.0%
Taylor expanded in y around 0 43.7%
+-commutative43.7%
mul-1-neg43.7%
unsub-neg43.7%
Simplified43.7%
Taylor expanded in j around -inf 50.9%
mul-1-neg50.9%
distribute-rgt-neg-in50.9%
+-commutative50.9%
mul-1-neg50.9%
unsub-neg50.9%
*-commutative50.9%
associate-*r*50.9%
*-commutative50.9%
associate-/l*50.9%
associate-/l*50.9%
*-commutative50.9%
Simplified50.9%
Taylor expanded in j around inf 50.9%
Simplified59.5%
if -1.99999999999999988e-11 < y < -7.00000000000000029e-74 or 4.69999999999999989e-26 < y < 4.5e108Initial program 72.0%
Taylor expanded in i around inf 56.9%
*-commutative56.9%
associate-*r*56.8%
Simplified56.8%
Taylor expanded in i around inf 62.2%
+-commutative62.2%
mul-1-neg62.2%
unsub-neg62.2%
*-commutative62.2%
Simplified62.2%
if -7.00000000000000029e-74 < y < 4.69999999999999989e-26Initial program 79.0%
+-commutative79.0%
fma-define79.0%
*-commutative79.0%
*-commutative79.0%
cancel-sign-sub-inv79.0%
cancel-sign-sub79.0%
sub-neg79.0%
sub-neg79.0%
*-commutative79.0%
fma-neg79.0%
*-commutative79.0%
distribute-rgt-neg-out79.0%
remove-double-neg79.0%
*-commutative79.0%
*-commutative79.0%
Simplified79.0%
Taylor expanded in c around inf 57.9%
Taylor expanded in j around inf 59.0%
mul-1-neg59.0%
unsub-neg59.0%
associate-/l*59.0%
Simplified59.0%
Final simplification63.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i))))
(t_2 (+ t_1 (* z (- (* x y) (* b c))))))
(if (<= b -3.2e-53)
(+ (* t (- (* c j) (* x a))) (* b (- (* a i) (* z c))))
(if (<= b -4.3e-203)
t_2
(if (<= b 5.9e-54)
(+ (* x (- (* y z) (* t a))) t_1)
(if (<= b 7.5e+70)
t_2
(- (* c (* t j)) (* i (- (* y j) (* a b))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = t_1 + (z * ((x * y) - (b * c)));
double tmp;
if (b <= -3.2e-53) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else if (b <= -4.3e-203) {
tmp = t_2;
} else if (b <= 5.9e-54) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else if (b <= 7.5e+70) {
tmp = t_2;
} else {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = j * ((t * c) - (y * i))
t_2 = t_1 + (z * ((x * y) - (b * c)))
if (b <= (-3.2d-53)) then
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)))
else if (b <= (-4.3d-203)) then
tmp = t_2
else if (b <= 5.9d-54) then
tmp = (x * ((y * z) - (t * a))) + t_1
else if (b <= 7.5d+70) then
tmp = t_2
else
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = t_1 + (z * ((x * y) - (b * c)));
double tmp;
if (b <= -3.2e-53) {
tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c)));
} else if (b <= -4.3e-203) {
tmp = t_2;
} else if (b <= 5.9e-54) {
tmp = (x * ((y * z) - (t * a))) + t_1;
} else if (b <= 7.5e+70) {
tmp = t_2;
} else {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * ((t * c) - (y * i)) t_2 = t_1 + (z * ((x * y) - (b * c))) tmp = 0 if b <= -3.2e-53: tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))) elif b <= -4.3e-203: tmp = t_2 elif b <= 5.9e-54: tmp = (x * ((y * z) - (t * a))) + t_1 elif b <= 7.5e+70: tmp = t_2 else: tmp = (c * (t * j)) - (i * ((y * j) - (a * b))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) t_2 = Float64(t_1 + Float64(z * Float64(Float64(x * y) - Float64(b * c)))) tmp = 0.0 if (b <= -3.2e-53) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))); elseif (b <= -4.3e-203) tmp = t_2; elseif (b <= 5.9e-54) tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + t_1); elseif (b <= 7.5e+70) tmp = t_2; else tmp = Float64(Float64(c * Float64(t * j)) - Float64(i * Float64(Float64(y * j) - Float64(a * b)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * ((t * c) - (y * i)); t_2 = t_1 + (z * ((x * y) - (b * c))); tmp = 0.0; if (b <= -3.2e-53) tmp = (t * ((c * j) - (x * a))) + (b * ((a * i) - (z * c))); elseif (b <= -4.3e-203) tmp = t_2; elseif (b <= 5.9e-54) tmp = (x * ((y * z) - (t * a))) + t_1; elseif (b <= 7.5e+70) tmp = t_2; else tmp = (c * (t * j)) - (i * ((y * j) - (a * b))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -3.2e-53], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -4.3e-203], t$95$2, If[LessEqual[b, 5.9e-54], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[b, 7.5e+70], t$95$2, N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(y * j), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
t_2 := t\_1 + z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{if}\;b \leq -3.2 \cdot 10^{-53}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{elif}\;b \leq -4.3 \cdot 10^{-203}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq 5.9 \cdot 10^{-54}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + t\_1\\
\mathbf{elif}\;b \leq 7.5 \cdot 10^{+70}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) - i \cdot \left(y \cdot j - a \cdot b\right)\\
\end{array}
\end{array}
if b < -3.2000000000000001e-53Initial program 70.6%
+-commutative70.6%
fma-define70.6%
*-commutative70.6%
*-commutative70.6%
cancel-sign-sub-inv70.6%
cancel-sign-sub70.6%
sub-neg70.6%
sub-neg70.6%
*-commutative70.6%
fma-neg72.4%
*-commutative72.4%
distribute-rgt-neg-out72.4%
remove-double-neg72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Taylor expanded in y around 0 76.1%
mul-1-neg76.1%
associate-*r*72.4%
*-commutative72.4%
associate-*l*74.5%
distribute-rgt-neg-in74.5%
mul-1-neg74.5%
*-commutative74.5%
*-commutative74.5%
associate-*r*78.2%
*-commutative78.2%
distribute-lft-in80.0%
+-commutative80.0%
mul-1-neg80.0%
unsub-neg80.0%
*-commutative80.0%
*-commutative80.0%
Simplified80.0%
if -3.2000000000000001e-53 < b < -4.30000000000000027e-203 or 5.90000000000000024e-54 < b < 7.50000000000000031e70Initial program 72.7%
Taylor expanded in z around inf 75.8%
*-commutative75.8%
*-commutative75.8%
Simplified75.8%
if -4.30000000000000027e-203 < b < 5.90000000000000024e-54Initial program 75.6%
Taylor expanded in x around inf 75.1%
if 7.50000000000000031e70 < b Initial program 69.8%
Taylor expanded in i around inf 61.4%
*-commutative61.4%
associate-*r*64.6%
Simplified64.6%
Taylor expanded in i around 0 74.3%
Final simplification76.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))) (t_2 (* t (- (* c j) (* x a)))))
(if (<= t -7.2e+218)
t_2
(if (<= t -1.95e+148)
t_1
(if (<= t -8.8e+105)
t_2
(if (<= t -1.32e-37)
(* c (- (* t j) (* z b)))
(if (<= t 1.2e+33) 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 = t * ((c * j) - (x * a));
double tmp;
if (t <= -7.2e+218) {
tmp = t_2;
} else if (t <= -1.95e+148) {
tmp = t_1;
} else if (t <= -8.8e+105) {
tmp = t_2;
} else if (t <= -1.32e-37) {
tmp = c * ((t * j) - (z * b));
} else if (t <= 1.2e+33) {
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 = t * ((c * j) - (x * a))
if (t <= (-7.2d+218)) then
tmp = t_2
else if (t <= (-1.95d+148)) then
tmp = t_1
else if (t <= (-8.8d+105)) then
tmp = t_2
else if (t <= (-1.32d-37)) then
tmp = c * ((t * j) - (z * b))
else if (t <= 1.2d+33) 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 = t * ((c * j) - (x * a));
double tmp;
if (t <= -7.2e+218) {
tmp = t_2;
} else if (t <= -1.95e+148) {
tmp = t_1;
} else if (t <= -8.8e+105) {
tmp = t_2;
} else if (t <= -1.32e-37) {
tmp = c * ((t * j) - (z * b));
} else if (t <= 1.2e+33) {
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 = t * ((c * j) - (x * a)) tmp = 0 if t <= -7.2e+218: tmp = t_2 elif t <= -1.95e+148: tmp = t_1 elif t <= -8.8e+105: tmp = t_2 elif t <= -1.32e-37: tmp = c * ((t * j) - (z * b)) elif t <= 1.2e+33: 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(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -7.2e+218) tmp = t_2; elseif (t <= -1.95e+148) tmp = t_1; elseif (t <= -8.8e+105) tmp = t_2; elseif (t <= -1.32e-37) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (t <= 1.2e+33) 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 = t * ((c * j) - (x * a)); tmp = 0.0; if (t <= -7.2e+218) tmp = t_2; elseif (t <= -1.95e+148) tmp = t_1; elseif (t <= -8.8e+105) tmp = t_2; elseif (t <= -1.32e-37) tmp = c * ((t * j) - (z * b)); elseif (t <= 1.2e+33) 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[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -7.2e+218], t$95$2, If[LessEqual[t, -1.95e+148], t$95$1, If[LessEqual[t, -8.8e+105], t$95$2, If[LessEqual[t, -1.32e-37], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.2e+33], 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 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -7.2 \cdot 10^{+218}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -1.95 \cdot 10^{+148}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq -8.8 \cdot 10^{+105}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t \leq -1.32 \cdot 10^{-37}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;t \leq 1.2 \cdot 10^{+33}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if t < -7.19999999999999981e218 or -1.95000000000000001e148 < t < -8.80000000000000027e105 or 1.2e33 < t Initial program 60.7%
+-commutative60.7%
fma-define60.7%
*-commutative60.7%
*-commutative60.7%
cancel-sign-sub-inv60.7%
cancel-sign-sub60.7%
sub-neg60.7%
sub-neg60.7%
*-commutative60.7%
fma-neg61.9%
*-commutative61.9%
distribute-rgt-neg-out61.9%
remove-double-neg61.9%
*-commutative61.9%
*-commutative61.9%
Simplified61.9%
Taylor expanded in t around inf 76.6%
+-commutative76.6%
mul-1-neg76.6%
unsub-neg76.6%
*-commutative76.6%
Simplified76.6%
if -7.19999999999999981e218 < t < -1.95000000000000001e148 or -1.3200000000000001e-37 < t < 1.2e33Initial program 75.6%
Taylor expanded in i around inf 52.3%
*-commutative52.3%
associate-*r*50.7%
Simplified50.7%
Taylor expanded in i around inf 57.8%
+-commutative57.8%
mul-1-neg57.8%
unsub-neg57.8%
*-commutative57.8%
Simplified57.8%
if -8.80000000000000027e105 < t < -1.3200000000000001e-37Initial program 87.3%
+-commutative87.3%
fma-define87.3%
*-commutative87.3%
*-commutative87.3%
cancel-sign-sub-inv87.3%
cancel-sign-sub87.3%
sub-neg87.3%
sub-neg87.3%
*-commutative87.3%
fma-neg87.3%
*-commutative87.3%
distribute-rgt-neg-out87.3%
remove-double-neg87.3%
*-commutative87.3%
*-commutative87.3%
Simplified87.3%
Taylor expanded in c around inf 50.3%
Final simplification62.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -6.2e-52)
(+ (* t (- (* c j) (* x a))) t_1)
(if (or (<= b -4.6e-203) (not (<= b 1.9e-53)))
(+ (* y (- (* x z) (* i j))) t_1)
(+ (* x (- (* y z) (* t a))) (* j (- (* t c) (* y i))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -6.2e-52) {
tmp = (t * ((c * j) - (x * a))) + t_1;
} else if ((b <= -4.6e-203) || !(b <= 1.9e-53)) {
tmp = (y * ((x * z) - (i * j))) + t_1;
} else {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (b <= (-6.2d-52)) then
tmp = (t * ((c * j) - (x * a))) + t_1
else if ((b <= (-4.6d-203)) .or. (.not. (b <= 1.9d-53))) then
tmp = (y * ((x * z) - (i * j))) + t_1
else
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -6.2e-52) {
tmp = (t * ((c * j) - (x * a))) + t_1;
} else if ((b <= -4.6e-203) || !(b <= 1.9e-53)) {
tmp = (y * ((x * z) - (i * j))) + t_1;
} else {
tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -6.2e-52: tmp = (t * ((c * j) - (x * a))) + t_1 elif (b <= -4.6e-203) or not (b <= 1.9e-53): tmp = (y * ((x * z) - (i * j))) + t_1 else: tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))) return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -6.2e-52) tmp = Float64(Float64(t * Float64(Float64(c * j) - Float64(x * a))) + t_1); elseif ((b <= -4.6e-203) || !(b <= 1.9e-53)) tmp = Float64(Float64(y * Float64(Float64(x * z) - Float64(i * j))) + t_1); else tmp = Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -6.2e-52) tmp = (t * ((c * j) - (x * a))) + t_1; elseif ((b <= -4.6e-203) || ~((b <= 1.9e-53))) tmp = (y * ((x * z) - (i * j))) + t_1; else tmp = (x * ((y * z) - (t * a))) + (j * ((t * c) - (y * i))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -6.2e-52], N[(N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[Or[LessEqual[b, -4.6e-203], N[Not[LessEqual[b, 1.9e-53]], $MachinePrecision]], N[(N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -6.2 \cdot 10^{-52}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right) + t\_1\\
\mathbf{elif}\;b \leq -4.6 \cdot 10^{-203} \lor \neg \left(b \leq 1.9 \cdot 10^{-53}\right):\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right) + j \cdot \left(t \cdot c - y \cdot i\right)\\
\end{array}
\end{array}
if b < -6.1999999999999998e-52Initial program 70.6%
+-commutative70.6%
fma-define70.6%
*-commutative70.6%
*-commutative70.6%
cancel-sign-sub-inv70.6%
cancel-sign-sub70.6%
sub-neg70.6%
sub-neg70.6%
*-commutative70.6%
fma-neg72.4%
*-commutative72.4%
distribute-rgt-neg-out72.4%
remove-double-neg72.4%
*-commutative72.4%
*-commutative72.4%
Simplified72.4%
Taylor expanded in y around 0 76.1%
mul-1-neg76.1%
associate-*r*72.4%
*-commutative72.4%
associate-*l*74.5%
distribute-rgt-neg-in74.5%
mul-1-neg74.5%
*-commutative74.5%
*-commutative74.5%
associate-*r*78.2%
*-commutative78.2%
distribute-lft-in80.0%
+-commutative80.0%
mul-1-neg80.0%
unsub-neg80.0%
*-commutative80.0%
*-commutative80.0%
Simplified80.0%
if -6.1999999999999998e-52 < b < -4.59999999999999983e-203 or 1.8999999999999999e-53 < b Initial program 71.3%
+-commutative71.3%
fma-define71.3%
*-commutative71.3%
*-commutative71.3%
cancel-sign-sub-inv71.3%
cancel-sign-sub71.3%
sub-neg71.3%
sub-neg71.3%
*-commutative71.3%
fma-neg71.3%
*-commutative71.3%
distribute-rgt-neg-out71.3%
remove-double-neg71.3%
*-commutative71.3%
*-commutative71.3%
Simplified71.3%
Taylor expanded in t around 0 71.8%
associate-*r*73.5%
associate-*r*73.5%
*-commutative73.5%
associate-*r*76.5%
distribute-rgt-in76.5%
+-commutative76.5%
mul-1-neg76.5%
unsub-neg76.5%
*-commutative76.5%
*-commutative76.5%
Simplified76.5%
if -4.59999999999999983e-203 < b < 1.8999999999999999e-53Initial program 75.6%
Taylor expanded in x around inf 75.1%
Final simplification76.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -3.7e+96)
(* y (* i (+ (* a (/ b y)) (- (* x (/ z i)) j))))
(if (<= y -1.9e-149)
(+ (* j (- (* t c) (* y i))) (* z (- (* x y) (* b c))))
(if (<= y 2.3e+104)
(- (* c (* t j)) (* i (- (* y j) (* a b))))
(* y (+ (* x z) (- (/ (* a (* b i)) y) (* i j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -3.7e+96) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (y <= -1.9e-149) {
tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)));
} else if (y <= 2.3e+104) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-3.7d+96)) then
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)))
else if (y <= (-1.9d-149)) then
tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)))
else if (y <= 2.3d+104) then
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)))
else
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -3.7e+96) {
tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j)));
} else if (y <= -1.9e-149) {
tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c)));
} else if (y <= 2.3e+104) {
tmp = (c * (t * j)) - (i * ((y * j) - (a * b)));
} else {
tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j)));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -3.7e+96: tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))) elif y <= -1.9e-149: tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c))) elif y <= 2.3e+104: tmp = (c * (t * j)) - (i * ((y * j) - (a * b))) else: tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -3.7e+96) tmp = Float64(y * Float64(i * Float64(Float64(a * Float64(b / y)) + Float64(Float64(x * Float64(z / i)) - j)))); elseif (y <= -1.9e-149) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + Float64(z * Float64(Float64(x * y) - Float64(b * c)))); elseif (y <= 2.3e+104) tmp = Float64(Float64(c * Float64(t * j)) - Float64(i * Float64(Float64(y * j) - Float64(a * b)))); else tmp = Float64(y * Float64(Float64(x * z) + Float64(Float64(Float64(a * Float64(b * i)) / y) - Float64(i * j)))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -3.7e+96) tmp = y * (i * ((a * (b / y)) + ((x * (z / i)) - j))); elseif (y <= -1.9e-149) tmp = (j * ((t * c) - (y * i))) + (z * ((x * y) - (b * c))); elseif (y <= 2.3e+104) tmp = (c * (t * j)) - (i * ((y * j) - (a * b))); else tmp = y * ((x * z) + (((a * (b * i)) / y) - (i * j))); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -3.7e+96], N[(y * N[(i * N[(N[(a * N[(b / y), $MachinePrecision]), $MachinePrecision] + N[(N[(x * N[(z / i), $MachinePrecision]), $MachinePrecision] - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, -1.9e-149], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(x * y), $MachinePrecision] - N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2.3e+104], N[(N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision] - N[(i * N[(N[(y * j), $MachinePrecision] - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(x * z), $MachinePrecision] + N[(N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -3.7 \cdot 10^{+96}:\\
\;\;\;\;y \cdot \left(i \cdot \left(a \cdot \frac{b}{y} + \left(x \cdot \frac{z}{i} - j\right)\right)\right)\\
\mathbf{elif}\;y \leq -1.9 \cdot 10^{-149}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) + z \cdot \left(x \cdot y - b \cdot c\right)\\
\mathbf{elif}\;y \leq 2.3 \cdot 10^{+104}:\\
\;\;\;\;c \cdot \left(t \cdot j\right) - i \cdot \left(y \cdot j - a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot \left(x \cdot z + \left(\frac{a \cdot \left(b \cdot i\right)}{y} - i \cdot j\right)\right)\\
\end{array}
\end{array}
if y < -3.69999999999999991e96Initial program 65.6%
+-commutative65.6%
fma-define65.6%
*-commutative65.6%
*-commutative65.6%
cancel-sign-sub-inv65.6%
cancel-sign-sub65.6%
sub-neg65.6%
sub-neg65.6%
*-commutative65.6%
fma-neg65.6%
*-commutative65.6%
distribute-rgt-neg-out65.6%
remove-double-neg65.6%
*-commutative65.6%
*-commutative65.6%
Simplified65.6%
Taylor expanded in y around -inf 71.5%
Simplified75.4%
Taylor expanded in i around inf 78.0%
Taylor expanded in i around inf 80.1%
mul-1-neg80.1%
unsub-neg80.1%
associate-/l*81.9%
associate-/l*85.9%
Simplified85.9%
if -3.69999999999999991e96 < y < -1.90000000000000003e-149Initial program 78.8%
Taylor expanded in z around inf 68.1%
*-commutative68.1%
*-commutative68.1%
Simplified68.1%
if -1.90000000000000003e-149 < y < 2.29999999999999985e104Initial program 75.8%
Taylor expanded in i around inf 58.5%
*-commutative58.5%
associate-*r*56.7%
Simplified56.7%
Taylor expanded in i around 0 66.0%
if 2.29999999999999985e104 < y Initial program 62.9%
+-commutative62.9%
fma-define62.9%
*-commutative62.9%
*-commutative62.9%
cancel-sign-sub-inv62.9%
cancel-sign-sub62.9%
sub-neg62.9%
sub-neg62.9%
*-commutative62.9%
fma-neg65.4%
*-commutative65.4%
distribute-rgt-neg-out65.4%
remove-double-neg65.4%
*-commutative65.4%
*-commutative65.4%
Simplified65.4%
Taylor expanded in y around -inf 72.3%
Simplified74.9%
Taylor expanded in i around inf 75.1%
Final simplification71.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (* t c))))
(if (<= c -2.2e+124)
(* (* z b) (- c))
(if (<= c -4.8e-81)
t_1
(if (<= c 2.55e-287)
(* i (* a b))
(if (<= c 8e+19) (* (- a) (* 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 = j * (t * c);
double tmp;
if (c <= -2.2e+124) {
tmp = (z * b) * -c;
} else if (c <= -4.8e-81) {
tmp = t_1;
} else if (c <= 2.55e-287) {
tmp = i * (a * b);
} else if (c <= 8e+19) {
tmp = -a * (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 = j * (t * c)
if (c <= (-2.2d+124)) then
tmp = (z * b) * -c
else if (c <= (-4.8d-81)) then
tmp = t_1
else if (c <= 2.55d-287) then
tmp = i * (a * b)
else if (c <= 8d+19) then
tmp = -a * (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 = j * (t * c);
double tmp;
if (c <= -2.2e+124) {
tmp = (z * b) * -c;
} else if (c <= -4.8e-81) {
tmp = t_1;
} else if (c <= 2.55e-287) {
tmp = i * (a * b);
} else if (c <= 8e+19) {
tmp = -a * (x * t);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * (t * c) tmp = 0 if c <= -2.2e+124: tmp = (z * b) * -c elif c <= -4.8e-81: tmp = t_1 elif c <= 2.55e-287: tmp = i * (a * b) elif c <= 8e+19: tmp = -a * (x * t) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(t * c)) tmp = 0.0 if (c <= -2.2e+124) tmp = Float64(Float64(z * b) * Float64(-c)); elseif (c <= -4.8e-81) tmp = t_1; elseif (c <= 2.55e-287) tmp = Float64(i * Float64(a * b)); elseif (c <= 8e+19) tmp = Float64(Float64(-a) * 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 = j * (t * c); tmp = 0.0; if (c <= -2.2e+124) tmp = (z * b) * -c; elseif (c <= -4.8e-81) tmp = t_1; elseif (c <= 2.55e-287) tmp = i * (a * b); elseif (c <= 8e+19) tmp = -a * (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[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2.2e+124], N[(N[(z * b), $MachinePrecision] * (-c)), $MachinePrecision], If[LessEqual[c, -4.8e-81], t$95$1, If[LessEqual[c, 2.55e-287], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 8e+19], N[((-a) * N[(x * t), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c\right)\\
\mathbf{if}\;c \leq -2.2 \cdot 10^{+124}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \left(-c\right)\\
\mathbf{elif}\;c \leq -4.8 \cdot 10^{-81}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 2.55 \cdot 10^{-287}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;c \leq 8 \cdot 10^{+19}:\\
\;\;\;\;\left(-a\right) \cdot \left(x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -2.2000000000000001e124Initial program 58.8%
+-commutative58.8%
fma-define58.8%
*-commutative58.8%
*-commutative58.8%
cancel-sign-sub-inv58.8%
cancel-sign-sub58.8%
sub-neg58.8%
sub-neg58.8%
*-commutative58.8%
fma-neg58.8%
*-commutative58.8%
distribute-rgt-neg-out58.8%
remove-double-neg58.8%
*-commutative58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in c around inf 64.1%
Taylor expanded in j around 0 42.9%
neg-mul-142.9%
distribute-rgt-neg-in42.9%
Simplified42.9%
if -2.2000000000000001e124 < c < -4.7999999999999998e-81 or 8e19 < c Initial program 68.4%
Taylor expanded in x around inf 61.8%
Taylor expanded in y around 0 47.1%
+-commutative47.1%
mul-1-neg47.1%
unsub-neg47.1%
Simplified47.1%
Taylor expanded in c around inf 32.7%
*-commutative32.7%
associate-*r*38.4%
*-commutative38.4%
Simplified38.4%
if -4.7999999999999998e-81 < c < 2.5499999999999999e-287Initial program 88.7%
+-commutative88.7%
fma-define88.6%
*-commutative88.6%
*-commutative88.6%
cancel-sign-sub-inv88.6%
cancel-sign-sub88.6%
sub-neg88.6%
sub-neg88.6%
*-commutative88.6%
fma-neg88.6%
*-commutative88.6%
distribute-rgt-neg-out88.6%
remove-double-neg88.6%
*-commutative88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in y around -inf 76.8%
Simplified78.4%
Taylor expanded in i around inf 65.4%
Taylor expanded in a around inf 42.6%
associate-*r*42.7%
Simplified42.7%
if 2.5499999999999999e-287 < c < 8e19Initial program 71.2%
Taylor expanded in x around inf 63.0%
Taylor expanded in y around 0 31.6%
+-commutative31.6%
mul-1-neg31.6%
unsub-neg31.6%
Simplified31.6%
Taylor expanded in c around 0 29.9%
*-commutative29.9%
neg-mul-129.9%
distribute-rgt-neg-in29.9%
distribute-rgt-neg-in29.9%
Simplified29.9%
Final simplification38.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (* t c))))
(if (<= c -2.65e+126)
(* (* z b) (- c))
(if (<= c -4e-83)
t_1
(if (<= c 4.1e-280)
(* i (* a b))
(if (<= c 5e+19) (* t (* x (- a))) t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * (t * c);
double tmp;
if (c <= -2.65e+126) {
tmp = (z * b) * -c;
} else if (c <= -4e-83) {
tmp = t_1;
} else if (c <= 4.1e-280) {
tmp = i * (a * b);
} else if (c <= 5e+19) {
tmp = t * (x * -a);
} 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 = j * (t * c)
if (c <= (-2.65d+126)) then
tmp = (z * b) * -c
else if (c <= (-4d-83)) then
tmp = t_1
else if (c <= 4.1d-280) then
tmp = i * (a * b)
else if (c <= 5d+19) then
tmp = t * (x * -a)
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 = j * (t * c);
double tmp;
if (c <= -2.65e+126) {
tmp = (z * b) * -c;
} else if (c <= -4e-83) {
tmp = t_1;
} else if (c <= 4.1e-280) {
tmp = i * (a * b);
} else if (c <= 5e+19) {
tmp = t * (x * -a);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = j * (t * c) tmp = 0 if c <= -2.65e+126: tmp = (z * b) * -c elif c <= -4e-83: tmp = t_1 elif c <= 4.1e-280: tmp = i * (a * b) elif c <= 5e+19: tmp = t * (x * -a) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(t * c)) tmp = 0.0 if (c <= -2.65e+126) tmp = Float64(Float64(z * b) * Float64(-c)); elseif (c <= -4e-83) tmp = t_1; elseif (c <= 4.1e-280) tmp = Float64(i * Float64(a * b)); elseif (c <= 5e+19) tmp = Float64(t * Float64(x * Float64(-a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = j * (t * c); tmp = 0.0; if (c <= -2.65e+126) tmp = (z * b) * -c; elseif (c <= -4e-83) tmp = t_1; elseif (c <= 4.1e-280) tmp = i * (a * b); elseif (c <= 5e+19) tmp = t * (x * -a); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -2.65e+126], N[(N[(z * b), $MachinePrecision] * (-c)), $MachinePrecision], If[LessEqual[c, -4e-83], t$95$1, If[LessEqual[c, 4.1e-280], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 5e+19], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c\right)\\
\mathbf{if}\;c \leq -2.65 \cdot 10^{+126}:\\
\;\;\;\;\left(z \cdot b\right) \cdot \left(-c\right)\\
\mathbf{elif}\;c \leq -4 \cdot 10^{-83}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq 4.1 \cdot 10^{-280}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;c \leq 5 \cdot 10^{+19}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -2.65000000000000014e126Initial program 58.8%
+-commutative58.8%
fma-define58.8%
*-commutative58.8%
*-commutative58.8%
cancel-sign-sub-inv58.8%
cancel-sign-sub58.8%
sub-neg58.8%
sub-neg58.8%
*-commutative58.8%
fma-neg58.8%
*-commutative58.8%
distribute-rgt-neg-out58.8%
remove-double-neg58.8%
*-commutative58.8%
*-commutative58.8%
Simplified58.8%
Taylor expanded in c around inf 64.1%
Taylor expanded in j around 0 42.9%
neg-mul-142.9%
distribute-rgt-neg-in42.9%
Simplified42.9%
if -2.65000000000000014e126 < c < -4.0000000000000001e-83 or 5e19 < c Initial program 68.4%
Taylor expanded in x around inf 61.8%
Taylor expanded in y around 0 47.1%
+-commutative47.1%
mul-1-neg47.1%
unsub-neg47.1%
Simplified47.1%
Taylor expanded in c around inf 32.7%
*-commutative32.7%
associate-*r*38.4%
*-commutative38.4%
Simplified38.4%
if -4.0000000000000001e-83 < c < 4.1000000000000002e-280Initial program 88.7%
+-commutative88.7%
fma-define88.6%
*-commutative88.6%
*-commutative88.6%
cancel-sign-sub-inv88.6%
cancel-sign-sub88.6%
sub-neg88.6%
sub-neg88.6%
*-commutative88.6%
fma-neg88.6%
*-commutative88.6%
distribute-rgt-neg-out88.6%
remove-double-neg88.6%
*-commutative88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in y around -inf 76.8%
Simplified78.4%
Taylor expanded in i around inf 65.4%
Taylor expanded in a around inf 42.6%
associate-*r*42.7%
Simplified42.7%
if 4.1000000000000002e-280 < c < 5e19Initial program 71.2%
+-commutative71.2%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
sub-neg71.2%
sub-neg71.2%
*-commutative71.2%
fma-neg71.2%
*-commutative71.2%
distribute-rgt-neg-out71.2%
remove-double-neg71.2%
*-commutative71.2%
*-commutative71.2%
Simplified71.2%
Taylor expanded in t around inf 39.5%
+-commutative39.5%
mul-1-neg39.5%
unsub-neg39.5%
*-commutative39.5%
Simplified39.5%
Taylor expanded in j around 0 36.1%
neg-mul-136.1%
distribute-lft-neg-in36.1%
*-commutative36.1%
Simplified36.1%
Final simplification39.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= c -4.4e+29)
(* b (* z (- c)))
(if (<= c -2.3e-90)
(* t (* c j))
(if (<= c 6.1e-283)
(* i (* a b))
(if (<= c 4e+19) (* t (* x (- a))) (* j (* t c)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (c <= -4.4e+29) {
tmp = b * (z * -c);
} else if (c <= -2.3e-90) {
tmp = t * (c * j);
} else if (c <= 6.1e-283) {
tmp = i * (a * b);
} else if (c <= 4e+19) {
tmp = t * (x * -a);
} else {
tmp = j * (t * 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 (c <= (-4.4d+29)) then
tmp = b * (z * -c)
else if (c <= (-2.3d-90)) then
tmp = t * (c * j)
else if (c <= 6.1d-283) then
tmp = i * (a * b)
else if (c <= 4d+19) then
tmp = t * (x * -a)
else
tmp = j * (t * 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 (c <= -4.4e+29) {
tmp = b * (z * -c);
} else if (c <= -2.3e-90) {
tmp = t * (c * j);
} else if (c <= 6.1e-283) {
tmp = i * (a * b);
} else if (c <= 4e+19) {
tmp = t * (x * -a);
} else {
tmp = j * (t * c);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if c <= -4.4e+29: tmp = b * (z * -c) elif c <= -2.3e-90: tmp = t * (c * j) elif c <= 6.1e-283: tmp = i * (a * b) elif c <= 4e+19: tmp = t * (x * -a) else: tmp = j * (t * c) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (c <= -4.4e+29) tmp = Float64(b * Float64(z * Float64(-c))); elseif (c <= -2.3e-90) tmp = Float64(t * Float64(c * j)); elseif (c <= 6.1e-283) tmp = Float64(i * Float64(a * b)); elseif (c <= 4e+19) tmp = Float64(t * Float64(x * Float64(-a))); else tmp = Float64(j * Float64(t * c)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (c <= -4.4e+29) tmp = b * (z * -c); elseif (c <= -2.3e-90) tmp = t * (c * j); elseif (c <= 6.1e-283) tmp = i * (a * b); elseif (c <= 4e+19) tmp = t * (x * -a); else tmp = j * (t * c); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[c, -4.4e+29], N[(b * N[(z * (-c)), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, -2.3e-90], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 6.1e-283], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4e+19], N[(t * N[(x * (-a)), $MachinePrecision]), $MachinePrecision], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -4.4 \cdot 10^{+29}:\\
\;\;\;\;b \cdot \left(z \cdot \left(-c\right)\right)\\
\mathbf{elif}\;c \leq -2.3 \cdot 10^{-90}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;c \leq 6.1 \cdot 10^{-283}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;c \leq 4 \cdot 10^{+19}:\\
\;\;\;\;t \cdot \left(x \cdot \left(-a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\end{array}
\end{array}
if c < -4.4000000000000003e29Initial program 58.4%
+-commutative58.4%
fma-define58.4%
*-commutative58.4%
*-commutative58.4%
cancel-sign-sub-inv58.4%
cancel-sign-sub58.4%
sub-neg58.4%
sub-neg58.4%
*-commutative58.4%
fma-neg58.4%
*-commutative58.4%
distribute-rgt-neg-out58.4%
remove-double-neg58.4%
*-commutative58.4%
*-commutative58.4%
Simplified58.4%
Taylor expanded in c around inf 55.5%
Taylor expanded in j around 0 38.2%
associate-*r*38.2%
neg-mul-138.2%
Simplified38.2%
if -4.4000000000000003e29 < c < -2.2999999999999998e-90Initial program 65.0%
+-commutative65.0%
fma-define65.0%
*-commutative65.0%
*-commutative65.0%
cancel-sign-sub-inv65.0%
cancel-sign-sub65.0%
sub-neg65.0%
sub-neg65.0%
*-commutative65.0%
fma-neg65.0%
*-commutative65.0%
distribute-rgt-neg-out65.0%
remove-double-neg65.0%
*-commutative65.0%
*-commutative65.0%
Simplified65.0%
Taylor expanded in t around inf 57.1%
+-commutative57.1%
mul-1-neg57.1%
unsub-neg57.1%
*-commutative57.1%
Simplified57.1%
Taylor expanded in j around inf 44.4%
if -2.2999999999999998e-90 < c < 6.1e-283Initial program 88.7%
+-commutative88.7%
fma-define88.6%
*-commutative88.6%
*-commutative88.6%
cancel-sign-sub-inv88.6%
cancel-sign-sub88.6%
sub-neg88.6%
sub-neg88.6%
*-commutative88.6%
fma-neg88.6%
*-commutative88.6%
distribute-rgt-neg-out88.6%
remove-double-neg88.6%
*-commutative88.6%
*-commutative88.6%
Simplified88.6%
Taylor expanded in y around -inf 76.8%
Simplified78.4%
Taylor expanded in i around inf 65.4%
Taylor expanded in a around inf 42.6%
associate-*r*42.7%
Simplified42.7%
if 6.1e-283 < c < 4e19Initial program 71.2%
+-commutative71.2%
fma-define71.2%
*-commutative71.2%
*-commutative71.2%
cancel-sign-sub-inv71.2%
cancel-sign-sub71.2%
sub-neg71.2%
sub-neg71.2%
*-commutative71.2%
fma-neg71.2%
*-commutative71.2%
distribute-rgt-neg-out71.2%
remove-double-neg71.2%
*-commutative71.2%
*-commutative71.2%
Simplified71.2%
Taylor expanded in t around inf 39.5%
+-commutative39.5%
mul-1-neg39.5%
unsub-neg39.5%
*-commutative39.5%
Simplified39.5%
Taylor expanded in j around 0 36.1%
neg-mul-136.1%
distribute-lft-neg-in36.1%
*-commutative36.1%
Simplified36.1%
if 4e19 < c Initial program 73.4%
Taylor expanded in x around inf 58.1%
Taylor expanded in y around 0 49.5%
+-commutative49.5%
mul-1-neg49.5%
unsub-neg49.5%
Simplified49.5%
Taylor expanded in c around inf 32.9%
*-commutative32.9%
associate-*r*39.6%
*-commutative39.6%
Simplified39.6%
Final simplification39.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* c (- (* t j) (* z b)))))
(if (<= c -1.4e+122)
t_1
(if (<= c -3.5e-84)
(* j (- (* t c) (* y i)))
(if (<= c 4e+85) (* i (- (* a b) (* y j))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.4e+122) {
tmp = t_1;
} else if (c <= -3.5e-84) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 4e+85) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = c * ((t * j) - (z * b))
if (c <= (-1.4d+122)) then
tmp = t_1
else if (c <= (-3.5d-84)) then
tmp = j * ((t * c) - (y * i))
else if (c <= 4d+85) then
tmp = i * ((a * b) - (y * j))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = c * ((t * j) - (z * b));
double tmp;
if (c <= -1.4e+122) {
tmp = t_1;
} else if (c <= -3.5e-84) {
tmp = j * ((t * c) - (y * i));
} else if (c <= 4e+85) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = c * ((t * j) - (z * b)) tmp = 0 if c <= -1.4e+122: tmp = t_1 elif c <= -3.5e-84: tmp = j * ((t * c) - (y * i)) elif c <= 4e+85: tmp = i * ((a * b) - (y * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(c * Float64(Float64(t * j) - Float64(z * b))) tmp = 0.0 if (c <= -1.4e+122) tmp = t_1; elseif (c <= -3.5e-84) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (c <= 4e+85) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = c * ((t * j) - (z * b)); tmp = 0.0; if (c <= -1.4e+122) tmp = t_1; elseif (c <= -3.5e-84) tmp = j * ((t * c) - (y * i)); elseif (c <= 4e+85) tmp = i * ((a * b) - (y * j)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[c, -1.4e+122], t$95$1, If[LessEqual[c, -3.5e-84], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[c, 4e+85], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{if}\;c \leq -1.4 \cdot 10^{+122}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;c \leq -3.5 \cdot 10^{-84}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;c \leq 4 \cdot 10^{+85}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if c < -1.4e122 or 4.0000000000000001e85 < c Initial program 66.3%
+-commutative66.3%
fma-define66.3%
*-commutative66.3%
*-commutative66.3%
cancel-sign-sub-inv66.3%
cancel-sign-sub66.3%
sub-neg66.3%
sub-neg66.3%
*-commutative66.3%
fma-neg66.3%
*-commutative66.3%
distribute-rgt-neg-out66.3%
remove-double-neg66.3%
*-commutative66.3%
*-commutative66.3%
Simplified66.3%
Taylor expanded in c around inf 64.7%
if -1.4e122 < c < -3.5000000000000001e-84Initial program 61.7%
Taylor expanded in i around inf 67.3%
*-commutative67.3%
associate-*r*65.0%
Simplified65.0%
Taylor expanded in b around 0 53.5%
if -3.5000000000000001e-84 < c < 4.0000000000000001e85Initial program 79.2%
Taylor expanded in i around inf 53.0%
*-commutative53.0%
associate-*r*54.4%
Simplified54.4%
Taylor expanded in i around inf 57.1%
+-commutative57.1%
mul-1-neg57.1%
unsub-neg57.1%
*-commutative57.1%
Simplified57.1%
Final simplification58.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -1.35e+78)
(* x (* y z))
(if (<= y 8.2e-23)
(* c (- (* t j) (* z b)))
(if (<= y 3.15e+106) (* i (* a b)) (* i (* j (- y)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -1.35e+78) {
tmp = x * (y * z);
} else if (y <= 8.2e-23) {
tmp = c * ((t * j) - (z * b));
} else if (y <= 3.15e+106) {
tmp = i * (a * b);
} else {
tmp = i * (j * -y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-1.35d+78)) then
tmp = x * (y * z)
else if (y <= 8.2d-23) then
tmp = c * ((t * j) - (z * b))
else if (y <= 3.15d+106) then
tmp = i * (a * b)
else
tmp = i * (j * -y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -1.35e+78) {
tmp = x * (y * z);
} else if (y <= 8.2e-23) {
tmp = c * ((t * j) - (z * b));
} else if (y <= 3.15e+106) {
tmp = i * (a * b);
} else {
tmp = i * (j * -y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -1.35e+78: tmp = x * (y * z) elif y <= 8.2e-23: tmp = c * ((t * j) - (z * b)) elif y <= 3.15e+106: tmp = i * (a * b) else: tmp = i * (j * -y) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -1.35e+78) tmp = Float64(x * Float64(y * z)); elseif (y <= 8.2e-23) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); elseif (y <= 3.15e+106) tmp = Float64(i * Float64(a * b)); else tmp = Float64(i * Float64(j * Float64(-y))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -1.35e+78) tmp = x * (y * z); elseif (y <= 8.2e-23) tmp = c * ((t * j) - (z * b)); elseif (y <= 3.15e+106) tmp = i * (a * b); else tmp = i * (j * -y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -1.35e+78], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 8.2e-23], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.15e+106], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(i * N[(j * (-y)), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.35 \cdot 10^{+78}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{-23}:\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{elif}\;y \leq 3.15 \cdot 10^{+106}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(j \cdot \left(-y\right)\right)\\
\end{array}
\end{array}
if y < -1.35000000000000002e78Initial program 63.8%
+-commutative63.8%
fma-define63.8%
*-commutative63.8%
*-commutative63.8%
cancel-sign-sub-inv63.8%
cancel-sign-sub63.8%
sub-neg63.8%
sub-neg63.8%
*-commutative63.8%
fma-neg63.8%
*-commutative63.8%
distribute-rgt-neg-out63.8%
remove-double-neg63.8%
*-commutative63.8%
*-commutative63.8%
Simplified63.8%
Taylor expanded in y around -inf 73.1%
Simplified76.9%
Taylor expanded in i around inf 79.2%
Taylor expanded in i around 0 45.4%
if -1.35000000000000002e78 < y < 8.20000000000000059e-23Initial program 81.0%
+-commutative81.0%
fma-define80.9%
*-commutative80.9%
*-commutative80.9%
cancel-sign-sub-inv80.9%
cancel-sign-sub80.9%
sub-neg80.9%
sub-neg80.9%
*-commutative80.9%
fma-neg80.9%
*-commutative80.9%
distribute-rgt-neg-out80.9%
remove-double-neg80.9%
*-commutative80.9%
*-commutative80.9%
Simplified80.9%
Taylor expanded in c around inf 48.7%
if 8.20000000000000059e-23 < y < 3.14999999999999987e106Initial program 64.6%
+-commutative64.6%
fma-define64.6%
*-commutative64.6%
*-commutative64.6%
cancel-sign-sub-inv64.6%
cancel-sign-sub64.6%
sub-neg64.6%
sub-neg64.6%
*-commutative64.6%
fma-neg64.6%
*-commutative64.6%
distribute-rgt-neg-out64.6%
remove-double-neg64.6%
*-commutative64.6%
*-commutative64.6%
Simplified64.6%
Taylor expanded in y around -inf 64.8%
Simplified77.3%
Taylor expanded in i around inf 57.9%
Taylor expanded in a around inf 46.4%
associate-*r*49.4%
Simplified49.4%
if 3.14999999999999987e106 < y Initial program 61.0%
Taylor expanded in i around inf 51.5%
*-commutative51.5%
associate-*r*51.5%
Simplified51.5%
Taylor expanded in y around inf 50.6%
associate-*r*50.6%
neg-mul-150.6%
Simplified50.6%
Final simplification48.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= y -1.62e-74)
t_1
(if (<= y 2.75e-288)
(* c (* t j))
(if (<= y 1.42e+109) (* a (* b i)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (y <= -1.62e-74) {
tmp = t_1;
} else if (y <= 2.75e-288) {
tmp = c * (t * j);
} else if (y <= 1.42e+109) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (y <= (-1.62d-74)) then
tmp = t_1
else if (y <= 2.75d-288) then
tmp = c * (t * j)
else if (y <= 1.42d+109) then
tmp = a * (b * i)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (y <= -1.62e-74) {
tmp = t_1;
} else if (y <= 2.75e-288) {
tmp = c * (t * j);
} else if (y <= 1.42e+109) {
tmp = a * (b * i);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if y <= -1.62e-74: tmp = t_1 elif y <= 2.75e-288: tmp = c * (t * j) elif y <= 1.42e+109: tmp = a * (b * i) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (y <= -1.62e-74) tmp = t_1; elseif (y <= 2.75e-288) tmp = Float64(c * Float64(t * j)); elseif (y <= 1.42e+109) tmp = Float64(a * Float64(b * i)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (y <= -1.62e-74) tmp = t_1; elseif (y <= 2.75e-288) tmp = c * (t * j); elseif (y <= 1.42e+109) tmp = a * (b * i); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.62e-74], t$95$1, If[LessEqual[y, 2.75e-288], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.42e+109], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;y \leq -1.62 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.75 \cdot 10^{-288}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;y \leq 1.42 \cdot 10^{+109}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.62000000000000007e-74 or 1.4200000000000001e109 < y Initial program 69.9%
+-commutative69.9%
fma-define69.9%
*-commutative69.9%
*-commutative69.9%
cancel-sign-sub-inv69.9%
cancel-sign-sub69.9%
sub-neg69.9%
sub-neg69.9%
*-commutative69.9%
fma-neg70.6%
*-commutative70.6%
distribute-rgt-neg-out70.6%
remove-double-neg70.6%
*-commutative70.6%
*-commutative70.6%
Simplified70.6%
Taylor expanded in y around -inf 73.7%
Simplified77.2%
Taylor expanded in i around inf 66.1%
Taylor expanded in i around 0 33.2%
if -1.62000000000000007e-74 < y < 2.75e-288Initial program 81.2%
+-commutative81.2%
fma-define81.2%
*-commutative81.2%
*-commutative81.2%
cancel-sign-sub-inv81.2%
cancel-sign-sub81.2%
sub-neg81.2%
sub-neg81.2%
*-commutative81.2%
fma-neg81.2%
*-commutative81.2%
distribute-rgt-neg-out81.2%
remove-double-neg81.2%
*-commutative81.2%
*-commutative81.2%
Simplified81.2%
Taylor expanded in c around inf 66.8%
Taylor expanded in j around inf 39.8%
if 2.75e-288 < y < 1.4200000000000001e109Initial program 71.9%
+-commutative71.9%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
sub-neg71.9%
sub-neg71.9%
*-commutative71.9%
fma-neg71.9%
*-commutative71.9%
distribute-rgt-neg-out71.9%
remove-double-neg71.9%
*-commutative71.9%
*-commutative71.9%
Simplified71.9%
Taylor expanded in y around -inf 61.9%
Simplified67.2%
Taylor expanded in i around inf 45.5%
Taylor expanded in a around inf 39.3%
*-commutative39.3%
Simplified39.3%
Final simplification36.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= y -3e-77)
t_1
(if (<= y 3.75e-287)
(* c (* t j))
(if (<= y 1.16e+108) (* i (* a b)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (y <= -3e-77) {
tmp = t_1;
} else if (y <= 3.75e-287) {
tmp = c * (t * j);
} else if (y <= 1.16e+108) {
tmp = i * (a * b);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (y <= (-3d-77)) then
tmp = t_1
else if (y <= 3.75d-287) then
tmp = c * (t * j)
else if (y <= 1.16d+108) then
tmp = i * (a * b)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (y <= -3e-77) {
tmp = t_1;
} else if (y <= 3.75e-287) {
tmp = c * (t * j);
} else if (y <= 1.16e+108) {
tmp = i * (a * b);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = x * (y * z) tmp = 0 if y <= -3e-77: tmp = t_1 elif y <= 3.75e-287: tmp = c * (t * j) elif y <= 1.16e+108: tmp = i * (a * b) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(y * z)) tmp = 0.0 if (y <= -3e-77) tmp = t_1; elseif (y <= 3.75e-287) tmp = Float64(c * Float64(t * j)); elseif (y <= 1.16e+108) tmp = Float64(i * Float64(a * b)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (y <= -3e-77) tmp = t_1; elseif (y <= 3.75e-287) tmp = c * (t * j); elseif (y <= 1.16e+108) tmp = i * (a * b); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3e-77], t$95$1, If[LessEqual[y, 3.75e-287], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.16e+108], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;y \leq -3 \cdot 10^{-77}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 3.75 \cdot 10^{-287}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{elif}\;y \leq 1.16 \cdot 10^{+108}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -3.00000000000000016e-77 or 1.15999999999999995e108 < y Initial program 69.9%
+-commutative69.9%
fma-define69.9%
*-commutative69.9%
*-commutative69.9%
cancel-sign-sub-inv69.9%
cancel-sign-sub69.9%
sub-neg69.9%
sub-neg69.9%
*-commutative69.9%
fma-neg70.6%
*-commutative70.6%
distribute-rgt-neg-out70.6%
remove-double-neg70.6%
*-commutative70.6%
*-commutative70.6%
Simplified70.6%
Taylor expanded in y around -inf 73.7%
Simplified77.2%
Taylor expanded in i around inf 66.1%
Taylor expanded in i around 0 33.2%
if -3.00000000000000016e-77 < y < 3.75e-287Initial program 81.2%
+-commutative81.2%
fma-define81.2%
*-commutative81.2%
*-commutative81.2%
cancel-sign-sub-inv81.2%
cancel-sign-sub81.2%
sub-neg81.2%
sub-neg81.2%
*-commutative81.2%
fma-neg81.2%
*-commutative81.2%
distribute-rgt-neg-out81.2%
remove-double-neg81.2%
*-commutative81.2%
*-commutative81.2%
Simplified81.2%
Taylor expanded in c around inf 66.8%
Taylor expanded in j around inf 39.8%
if 3.75e-287 < y < 1.15999999999999995e108Initial program 71.9%
+-commutative71.9%
fma-define71.9%
*-commutative71.9%
*-commutative71.9%
cancel-sign-sub-inv71.9%
cancel-sign-sub71.9%
sub-neg71.9%
sub-neg71.9%
*-commutative71.9%
fma-neg71.9%
*-commutative71.9%
distribute-rgt-neg-out71.9%
remove-double-neg71.9%
*-commutative71.9%
*-commutative71.9%
Simplified71.9%
Taylor expanded in y around -inf 61.9%
Simplified67.2%
Taylor expanded in i around inf 45.5%
Taylor expanded in a around inf 39.3%
associate-*r*40.7%
Simplified40.7%
Final simplification36.6%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= c -4.8e-81) (not (<= c 3.8e+85))) (* c (- (* t j) (* z b))) (* i (- (* a b) (* y j)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -4.8e-81) || !(c <= 3.8e+85)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((c <= (-4.8d-81)) .or. (.not. (c <= 3.8d+85))) then
tmp = c * ((t * j) - (z * b))
else
tmp = i * ((a * b) - (y * j))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((c <= -4.8e-81) || !(c <= 3.8e+85)) {
tmp = c * ((t * j) - (z * b));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (c <= -4.8e-81) or not (c <= 3.8e+85): tmp = c * ((t * j) - (z * b)) else: tmp = i * ((a * b) - (y * j)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((c <= -4.8e-81) || !(c <= 3.8e+85)) tmp = Float64(c * Float64(Float64(t * j) - Float64(z * b))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((c <= -4.8e-81) || ~((c <= 3.8e+85))) tmp = c * ((t * j) - (z * b)); else tmp = i * ((a * b) - (y * j)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[c, -4.8e-81], N[Not[LessEqual[c, 3.8e+85]], $MachinePrecision]], N[(c * N[(N[(t * j), $MachinePrecision] - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;c \leq -4.8 \cdot 10^{-81} \lor \neg \left(c \leq 3.8 \cdot 10^{+85}\right):\\
\;\;\;\;c \cdot \left(t \cdot j - z \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if c < -4.7999999999999998e-81 or 3.79999999999999992e85 < c Initial program 64.7%
+-commutative64.7%
fma-define64.7%
*-commutative64.7%
*-commutative64.7%
cancel-sign-sub-inv64.7%
cancel-sign-sub64.7%
sub-neg64.7%
sub-neg64.7%
*-commutative64.7%
fma-neg64.7%
*-commutative64.7%
distribute-rgt-neg-out64.7%
remove-double-neg64.7%
*-commutative64.7%
*-commutative64.7%
Simplified64.7%
Taylor expanded in c around inf 56.6%
if -4.7999999999999998e-81 < c < 3.79999999999999992e85Initial program 79.2%
Taylor expanded in i around inf 53.0%
*-commutative53.0%
associate-*r*54.4%
Simplified54.4%
Taylor expanded in i around inf 57.1%
+-commutative57.1%
mul-1-neg57.1%
unsub-neg57.1%
*-commutative57.1%
Simplified57.1%
Final simplification56.9%
(FPCore (x y z t a b c i j) :precision binary64 (if (or (<= a -1.55e-27) (not (<= a 8.5e-30))) (* b (* a i)) (* c (* t j))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((a <= -1.55e-27) || !(a <= 8.5e-30)) {
tmp = b * (a * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if ((a <= (-1.55d-27)) .or. (.not. (a <= 8.5d-30))) then
tmp = b * (a * i)
else
tmp = c * (t * j)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if ((a <= -1.55e-27) || !(a <= 8.5e-30)) {
tmp = b * (a * i);
} else {
tmp = c * (t * j);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if (a <= -1.55e-27) or not (a <= 8.5e-30): tmp = b * (a * i) else: tmp = c * (t * j) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if ((a <= -1.55e-27) || !(a <= 8.5e-30)) tmp = Float64(b * Float64(a * i)); else tmp = Float64(c * Float64(t * j)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if ((a <= -1.55e-27) || ~((a <= 8.5e-30))) tmp = b * (a * i); else tmp = c * (t * j); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[Or[LessEqual[a, -1.55e-27], N[Not[LessEqual[a, 8.5e-30]], $MachinePrecision]], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1.55 \cdot 10^{-27} \lor \neg \left(a \leq 8.5 \cdot 10^{-30}\right):\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\end{array}
\end{array}
if a < -1.5499999999999999e-27 or 8.49999999999999931e-30 < a Initial program 62.4%
+-commutative62.4%
fma-define62.4%
*-commutative62.4%
*-commutative62.4%
cancel-sign-sub-inv62.4%
cancel-sign-sub62.4%
sub-neg62.4%
sub-neg62.4%
*-commutative62.4%
fma-neg63.2%
*-commutative63.2%
distribute-rgt-neg-out63.2%
remove-double-neg63.2%
*-commutative63.2%
*-commutative63.2%
Simplified63.2%
Taylor expanded in y around -inf 65.1%
Simplified65.8%
Taylor expanded in i around inf 53.7%
Taylor expanded in a around inf 34.2%
*-commutative34.2%
Simplified34.2%
Taylor expanded in a around 0 34.2%
*-commutative34.2%
associate-*l*36.3%
Simplified36.3%
if -1.5499999999999999e-27 < a < 8.49999999999999931e-30Initial program 83.4%
+-commutative83.4%
fma-define83.4%
*-commutative83.4%
*-commutative83.4%
cancel-sign-sub-inv83.4%
cancel-sign-sub83.4%
sub-neg83.4%
sub-neg83.4%
*-commutative83.4%
fma-neg83.4%
*-commutative83.4%
distribute-rgt-neg-out83.4%
remove-double-neg83.4%
*-commutative83.4%
*-commutative83.4%
Simplified83.4%
Taylor expanded in c around inf 43.0%
Taylor expanded in j around inf 27.9%
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.5%
+-commutative72.5%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
sub-neg72.5%
sub-neg72.5%
*-commutative72.5%
fma-neg72.9%
*-commutative72.9%
distribute-rgt-neg-out72.9%
remove-double-neg72.9%
*-commutative72.9%
*-commutative72.9%
Simplified72.9%
Taylor expanded in y around -inf 68.3%
Simplified71.3%
Taylor expanded in i around inf 51.3%
Taylor expanded in a around inf 23.2%
*-commutative23.2%
Simplified23.2%
Final simplification23.2%
(FPCore (x y z t a b c i j) :precision binary64 (* b (* a i)))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = b * (a * i)
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return b * (a * i);
}
def code(x, y, z, t, a, b, c, i, j): return b * (a * i)
function code(x, y, z, t, a, b, c, i, j) return Float64(b * Float64(a * i)) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = b * (a * i); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
b \cdot \left(a \cdot i\right)
\end{array}
Initial program 72.5%
+-commutative72.5%
fma-define72.5%
*-commutative72.5%
*-commutative72.5%
cancel-sign-sub-inv72.5%
cancel-sign-sub72.5%
sub-neg72.5%
sub-neg72.5%
*-commutative72.5%
fma-neg72.9%
*-commutative72.9%
distribute-rgt-neg-out72.9%
remove-double-neg72.9%
*-commutative72.9%
*-commutative72.9%
Simplified72.9%
Taylor expanded in y around -inf 68.3%
Simplified71.3%
Taylor expanded in i around inf 51.3%
Taylor expanded in a around inf 23.2%
*-commutative23.2%
Simplified23.2%
Taylor expanded in a around 0 23.2%
*-commutative23.2%
associate-*l*23.5%
Simplified23.5%
Final simplification23.5%
(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 2024055
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(if (< t -8.120978919195912e-33) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -4.712553818218485e-169) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (if (< t -7.633533346031584e-308) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 1.0535888557455487e-139) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2.0) (pow (* i y) 2.0))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))