
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 26 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b c i j) :precision binary64 (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
code = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)));
}
def code(x, y, z, t, a, b, c, i, j): return ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y)))
function code(x, y, z, t, a, b, c, i, j) return Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(j * Float64(Float64(c * t) - Float64(i * y)))) end
function tmp = code(x, y, z, t, a, b, c, i, j) tmp = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + (j * ((c * t) - (i * y))); end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(c * t), $MachinePrecision] - N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + j \cdot \left(c \cdot t - i \cdot y\right)
\end{array}
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(+ (* x (- (* y z) (* t a))) (* b (- (* a i) (* z c))))
(* j (- (* t c) (* y i))))))
(if (<= t_1 INFINITY) t_1 (* a (* (- 0.0 b) (fma c (/ z a) (- 0.0 i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = a * ((0.0 - b) * fma(c, (z / a), (0.0 - i)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) + Float64(b * Float64(Float64(a * i) - Float64(z * c)))) + Float64(j * Float64(Float64(t * c) - Float64(y * i)))) tmp = 0.0 if (t_1 <= Inf) tmp = t_1; else tmp = Float64(a * Float64(Float64(0.0 - b) * fma(c, Float64(z / a), Float64(0.0 - i)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, Infinity], t$95$1, N[(a * N[(N[(0.0 - b), $MachinePrecision] * N[(c * N[(z / a), $MachinePrecision] + N[(0.0 - i), $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}:\\
\;\;\;\;a \cdot \left(\left(0 - b\right) \cdot \mathsf{fma}\left(c, \frac{z}{a}, 0 - i\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 91.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)))) Initial program 0.0%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f642.0
Simplified2.0%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6453.3
Simplified53.3%
Final simplification84.1%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(* j (- (* t c) (* y i)))
(fma b (fma c (- 0.0 z) (* a i)) (* y (* x z))))))
(if (<= j -7.8e-10)
t_1
(if (<= j 2.6e-75)
(fma z (fma c (- 0.0 b) (* x y)) (* a (fma t (- 0.0 x) (* 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 = (j * ((t * c) - (y * i))) + fma(b, fma(c, (0.0 - z), (a * i)), (y * (x * z)));
double tmp;
if (j <= -7.8e-10) {
tmp = t_1;
} else if (j <= 2.6e-75) {
tmp = fma(z, fma(c, (0.0 - b), (x * y)), (a * fma(t, (0.0 - x), (b * i))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) + fma(b, fma(c, Float64(0.0 - z), Float64(a * i)), Float64(y * Float64(x * z)))) tmp = 0.0 if (j <= -7.8e-10) tmp = t_1; elseif (j <= 2.6e-75) tmp = fma(z, fma(c, Float64(0.0 - b), Float64(x * y)), Float64(a * fma(t, Float64(0.0 - x), Float64(b * i)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * N[(0.0 - z), $MachinePrecision] + N[(a * i), $MachinePrecision]), $MachinePrecision] + N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -7.8e-10], t$95$1, If[LessEqual[j, 2.6e-75], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * N[(0.0 - x), $MachinePrecision] + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right) + \mathsf{fma}\left(b, \mathsf{fma}\left(c, 0 - z, a \cdot i\right), y \cdot \left(x \cdot z\right)\right)\\
\mathbf{if}\;j \leq -7.8 \cdot 10^{-10}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 2.6 \cdot 10^{-75}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(c, 0 - b, x \cdot y\right), a \cdot \mathsf{fma}\left(t, 0 - x, b \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -7.7999999999999999e-10 or 2.6e-75 < j Initial program 75.0%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6478.6
Simplified78.6%
if -7.7999999999999999e-10 < j < 2.6e-75Initial program 71.8%
Taylor expanded in i around 0
Simplified82.9%
Taylor expanded in j around 0
Simplified78.6%
Final simplification78.6%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= j -1.15e+32)
(- (* j (- (* t c) (* y i))) (* c (* z b)))
(if (<= j 1.05e-90)
(fma z (fma c (- 0.0 b) (* x y)) (* a (fma t (- 0.0 x) (* b i))))
(if (<= j 2.7e+162)
(fma y (fma j (- 0.0 i) (* x z)) (* b (fma c (- 0.0 z) (* a i))))
(* j (fma c t (* y (- 0.0 i))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -1.15e+32) {
tmp = (j * ((t * c) - (y * i))) - (c * (z * b));
} else if (j <= 1.05e-90) {
tmp = fma(z, fma(c, (0.0 - b), (x * y)), (a * fma(t, (0.0 - x), (b * i))));
} else if (j <= 2.7e+162) {
tmp = fma(y, fma(j, (0.0 - i), (x * z)), (b * fma(c, (0.0 - z), (a * i))));
} else {
tmp = j * fma(c, t, (y * (0.0 - i)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -1.15e+32) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(c * Float64(z * b))); elseif (j <= 1.05e-90) tmp = fma(z, fma(c, Float64(0.0 - b), Float64(x * y)), Float64(a * fma(t, Float64(0.0 - x), Float64(b * i)))); elseif (j <= 2.7e+162) tmp = fma(y, fma(j, Float64(0.0 - i), Float64(x * z)), Float64(b * fma(c, Float64(0.0 - z), Float64(a * i)))); else tmp = Float64(j * fma(c, t, Float64(y * Float64(0.0 - i)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -1.15e+32], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 1.05e-90], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(a * N[(t * N[(0.0 - x), $MachinePrecision] + N[(b * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 2.7e+162], N[(y * N[(j * N[(0.0 - i), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * N[(0.0 - z), $MachinePrecision] + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(c * t + N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -1.15 \cdot 10^{+32}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - c \cdot \left(z \cdot b\right)\\
\mathbf{elif}\;j \leq 1.05 \cdot 10^{-90}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(c, 0 - b, x \cdot y\right), a \cdot \mathsf{fma}\left(t, 0 - x, b \cdot i\right)\right)\\
\mathbf{elif}\;j \leq 2.7 \cdot 10^{+162}:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(j, 0 - i, x \cdot z\right), b \cdot \mathsf{fma}\left(c, 0 - z, a \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \mathsf{fma}\left(c, t, y \cdot \left(0 - i\right)\right)\\
\end{array}
\end{array}
if j < -1.15e32Initial program 70.5%
Taylor expanded in c around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6477.1
Simplified77.1%
if -1.15e32 < j < 1.05e-90Initial program 74.5%
Taylor expanded in i around 0
Simplified84.2%
Taylor expanded in j around 0
Simplified76.3%
if 1.05e-90 < j < 2.7000000000000002e162Initial program 74.2%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
Simplified76.4%
if 2.7000000000000002e162 < j Initial program 74.9%
Taylor expanded in j around inf
*-lowering-*.f64N/A
sub-negN/A
accelerator-lowering-fma.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6469.5
Simplified69.5%
Final simplification75.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* t (- (* c j) (* x a)))))
(if (<= t -8.5e+275)
t_1
(if (<= t 1e+61)
(fma y (fma j (- 0.0 i) (* x z)) (* b (fma c (- 0.0 z) (* a 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 = t * ((c * j) - (x * a));
double tmp;
if (t <= -8.5e+275) {
tmp = t_1;
} else if (t <= 1e+61) {
tmp = fma(y, fma(j, (0.0 - i), (x * z)), (b * fma(c, (0.0 - z), (a * i))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -8.5e+275) tmp = t_1; elseif (t <= 1e+61) tmp = fma(y, fma(j, Float64(0.0 - i), Float64(x * z)), Float64(b * fma(c, Float64(0.0 - z), Float64(a * i)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -8.5e+275], t$95$1, If[LessEqual[t, 1e+61], N[(y * N[(j * N[(0.0 - i), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision] + N[(b * N[(c * N[(0.0 - z), $MachinePrecision] + N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -8.5 \cdot 10^{+275}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 10^{+61}:\\
\;\;\;\;\mathsf{fma}\left(y, \mathsf{fma}\left(j, 0 - i, x \cdot z\right), b \cdot \mathsf{fma}\left(c, 0 - z, a \cdot i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -8.49999999999999958e275 or 9.99999999999999949e60 < t Initial program 66.4%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
Applied egg-rr66.4%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6468.7
Simplified68.7%
if -8.49999999999999958e275 < t < 9.99999999999999949e60Initial program 75.5%
Taylor expanded in t around 0
sub-negN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
Simplified72.2%
Final simplification71.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -8e+118)
t_1
(if (<= x -9.5e-15)
(* (- 0.0 j) (fma b (/ (* z c) j) (* y i)))
(if (<= x 0.0305)
(+ (* a (* b i)) (* c (fma b (- 0.0 z) (* t j))))
(if (<= x 2.25e+214) t_1 (* z (fma c (- 0.0 b) (* x y)))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -8e+118) {
tmp = t_1;
} else if (x <= -9.5e-15) {
tmp = (0.0 - j) * fma(b, ((z * c) / j), (y * i));
} else if (x <= 0.0305) {
tmp = (a * (b * i)) + (c * fma(b, (0.0 - z), (t * j)));
} else if (x <= 2.25e+214) {
tmp = t_1;
} else {
tmp = z * fma(c, (0.0 - b), (x * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -8e+118) tmp = t_1; elseif (x <= -9.5e-15) tmp = Float64(Float64(0.0 - j) * fma(b, Float64(Float64(z * c) / j), Float64(y * i))); elseif (x <= 0.0305) tmp = Float64(Float64(a * Float64(b * i)) + Float64(c * fma(b, Float64(0.0 - z), Float64(t * j)))); elseif (x <= 2.25e+214) tmp = t_1; else tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -8e+118], t$95$1, If[LessEqual[x, -9.5e-15], N[(N[(0.0 - j), $MachinePrecision] * N[(b * N[(N[(z * c), $MachinePrecision] / j), $MachinePrecision] + N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.0305], N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] + N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.25e+214], t$95$1, N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -8 \cdot 10^{+118}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -9.5 \cdot 10^{-15}:\\
\;\;\;\;\left(0 - j\right) \cdot \mathsf{fma}\left(b, \frac{z \cdot c}{j}, y \cdot i\right)\\
\mathbf{elif}\;x \leq 0.0305:\\
\;\;\;\;a \cdot \left(b \cdot i\right) + c \cdot \mathsf{fma}\left(b, 0 - z, t \cdot j\right)\\
\mathbf{elif}\;x \leq 2.25 \cdot 10^{+214}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\end{array}
\end{array}
if x < -7.99999999999999973e118 or 0.030499999999999999 < x < 2.24999999999999984e214Initial program 78.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6475.2
Simplified75.2%
if -7.99999999999999973e118 < x < -9.5000000000000005e-15Initial program 63.4%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.4
Simplified63.4%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6471.0
Simplified71.0%
Taylor expanded in t around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6470.0
Simplified70.0%
Taylor expanded in j around inf
*-lowering-*.f64N/A
+-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.4
Simplified82.4%
if -9.5000000000000005e-15 < x < 0.030499999999999999Initial program 73.9%
Taylor expanded in i around 0
Simplified78.8%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f6461.7
Simplified61.7%
if 2.24999999999999984e214 < x Initial program 49.7%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6483.3
Simplified83.3%
sub0-negN/A
neg-lowering-neg.f6483.3
Applied egg-rr83.3%
Final simplification68.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (fma c (- 0.0 b) (* x y)))) (t_2 (* x (- (* y z) (* t a)))))
(if (<= x -1.6e+210)
t_2
(if (<= x -1.5e+65)
t_1
(if (<= x 0.022)
(+ (* a (* b i)) (* c (fma b (- 0.0 z) (* t j))))
(if (<= x 8.8e+219) t_2 t_1))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * fma(c, (0.0 - b), (x * y));
double t_2 = x * ((y * z) - (t * a));
double tmp;
if (x <= -1.6e+210) {
tmp = t_2;
} else if (x <= -1.5e+65) {
tmp = t_1;
} else if (x <= 0.022) {
tmp = (a * (b * i)) + (c * fma(b, (0.0 - z), (t * j)));
} else if (x <= 8.8e+219) {
tmp = t_2;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))) t_2 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -1.6e+210) tmp = t_2; elseif (x <= -1.5e+65) tmp = t_1; elseif (x <= 0.022) tmp = Float64(Float64(a * Float64(b * i)) + Float64(c * fma(b, Float64(0.0 - z), Float64(t * j)))); elseif (x <= 8.8e+219) tmp = t_2; else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.6e+210], t$95$2, If[LessEqual[x, -1.5e+65], t$95$1, If[LessEqual[x, 0.022], N[(N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision] + N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 8.8e+219], t$95$2, t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
t_2 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -1.6 \cdot 10^{+210}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -1.5 \cdot 10^{+65}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 0.022:\\
\;\;\;\;a \cdot \left(b \cdot i\right) + c \cdot \mathsf{fma}\left(b, 0 - z, t \cdot j\right)\\
\mathbf{elif}\;x \leq 8.8 \cdot 10^{+219}:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -1.6000000000000001e210 or 0.021999999999999999 < x < 8.8000000000000006e219Initial program 77.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6476.7
Simplified76.7%
if -1.6000000000000001e210 < x < -1.5000000000000001e65 or 8.8000000000000006e219 < x Initial program 68.2%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6485.6
Simplified85.6%
sub0-negN/A
neg-lowering-neg.f6485.6
Applied egg-rr85.6%
if -1.5000000000000001e65 < x < 0.021999999999999999Initial program 73.3%
Taylor expanded in i around 0
Simplified77.7%
Taylor expanded in b around inf
*-lowering-*.f64N/A
*-lowering-*.f6460.5
Simplified60.5%
Final simplification68.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -1.2e+156)
(* x (- (* y z) (* t a)))
(if (<= x 1.55e+209)
(fma b (- (* a i) (* z c)) (* y (fma j (- 0.0 i) (* x z))))
(* z (fma c (- 0.0 b) (* x y))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.2e+156) {
tmp = x * ((y * z) - (t * a));
} else if (x <= 1.55e+209) {
tmp = fma(b, ((a * i) - (z * c)), (y * fma(j, (0.0 - i), (x * z))));
} else {
tmp = z * fma(c, (0.0 - b), (x * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -1.2e+156) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (x <= 1.55e+209) tmp = fma(b, Float64(Float64(a * i) - Float64(z * c)), Float64(y * fma(j, Float64(0.0 - i), Float64(x * z)))); else tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -1.2e+156], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.55e+209], N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision] + N[(y * N[(j * N[(0.0 - i), $MachinePrecision] + N[(x * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.2 \cdot 10^{+156}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;x \leq 1.55 \cdot 10^{+209}:\\
\;\;\;\;\mathsf{fma}\left(b, a \cdot i - z \cdot c, y \cdot \mathsf{fma}\left(j, 0 - i, x \cdot z\right)\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\end{array}
\end{array}
if x < -1.2000000000000001e156Initial program 63.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6491.8
Simplified91.8%
if -1.2000000000000001e156 < x < 1.55e209Initial program 76.5%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6475.7
Simplified75.7%
Taylor expanded in t around 0
+-commutativeN/A
associate-+l+N/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified66.6%
if 1.55e209 < x Initial program 53.6%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6476.9
Simplified76.9%
sub0-negN/A
neg-lowering-neg.f6476.9
Applied egg-rr76.9%
Final simplification70.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (* x y))))
(if (<= x -3e+58)
t_1
(if (<= x -1.45e-65)
(* t (* c j))
(if (<= x -1.02e-117)
(* b (* a i))
(if (<= x -2.1e-218)
(* c (- 0.0 (* z b)))
(if (<= x 0.015) (* i (* y (- 0.0 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 = z * (x * y);
double tmp;
if (x <= -3e+58) {
tmp = t_1;
} else if (x <= -1.45e-65) {
tmp = t * (c * j);
} else if (x <= -1.02e-117) {
tmp = b * (a * i);
} else if (x <= -2.1e-218) {
tmp = c * (0.0 - (z * b));
} else if (x <= 0.015) {
tmp = i * (y * (0.0 - 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 = z * (x * y)
if (x <= (-3d+58)) then
tmp = t_1
else if (x <= (-1.45d-65)) then
tmp = t * (c * j)
else if (x <= (-1.02d-117)) then
tmp = b * (a * i)
else if (x <= (-2.1d-218)) then
tmp = c * (0.0d0 - (z * b))
else if (x <= 0.015d0) then
tmp = i * (y * (0.0d0 - 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 = z * (x * y);
double tmp;
if (x <= -3e+58) {
tmp = t_1;
} else if (x <= -1.45e-65) {
tmp = t * (c * j);
} else if (x <= -1.02e-117) {
tmp = b * (a * i);
} else if (x <= -2.1e-218) {
tmp = c * (0.0 - (z * b));
} else if (x <= 0.015) {
tmp = i * (y * (0.0 - j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if x <= -3e+58: tmp = t_1 elif x <= -1.45e-65: tmp = t * (c * j) elif x <= -1.02e-117: tmp = b * (a * i) elif x <= -2.1e-218: tmp = c * (0.0 - (z * b)) elif x <= 0.015: tmp = i * (y * (0.0 - j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -3e+58) tmp = t_1; elseif (x <= -1.45e-65) tmp = Float64(t * Float64(c * j)); elseif (x <= -1.02e-117) tmp = Float64(b * Float64(a * i)); elseif (x <= -2.1e-218) tmp = Float64(c * Float64(0.0 - Float64(z * b))); elseif (x <= 0.015) tmp = Float64(i * Float64(y * Float64(0.0 - j))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (x <= -3e+58) tmp = t_1; elseif (x <= -1.45e-65) tmp = t * (c * j); elseif (x <= -1.02e-117) tmp = b * (a * i); elseif (x <= -2.1e-218) tmp = c * (0.0 - (z * b)); elseif (x <= 0.015) tmp = i * (y * (0.0 - 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[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3e+58], t$95$1, If[LessEqual[x, -1.45e-65], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.02e-117], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.1e-218], N[(c * N[(0.0 - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.015], N[(i * N[(y * N[(0.0 - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -3 \cdot 10^{+58}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.45 \cdot 10^{-65}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;x \leq -1.02 \cdot 10^{-117}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;x \leq -2.1 \cdot 10^{-218}:\\
\;\;\;\;c \cdot \left(0 - z \cdot b\right)\\
\mathbf{elif}\;x \leq 0.015:\\
\;\;\;\;i \cdot \left(y \cdot \left(0 - j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.0000000000000002e58 or 0.014999999999999999 < x Initial program 74.2%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6465.9
Simplified65.9%
Taylor expanded in c around 0
*-lowering-*.f6455.2
Simplified55.2%
if -3.0000000000000002e58 < x < -1.4499999999999999e-65Initial program 64.4%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.4
Simplified64.4%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6455.3
Simplified55.3%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6433.7
Simplified33.7%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6443.2
Applied egg-rr43.2%
if -1.4499999999999999e-65 < x < -1.01999999999999993e-117Initial program 99.9%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6482.6
Simplified82.6%
Taylor expanded in j around 0
*-lowering-*.f64N/A
*-lowering-*.f6456.3
Simplified56.3%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6473.0
Applied egg-rr73.0%
if -1.01999999999999993e-117 < x < -2.09999999999999994e-218Initial program 69.9%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6457.2
Simplified57.2%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6469.8
Simplified69.8%
Taylor expanded in t around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6465.5
Simplified65.5%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6461.7
Simplified61.7%
if -2.09999999999999994e-218 < x < 0.014999999999999999Initial program 72.6%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6451.3
Simplified51.3%
Taylor expanded in j around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6431.8
Simplified31.8%
Final simplification46.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (* x y))))
(if (<= x -5.5e+60)
t_1
(if (<= x -2.3e-65)
(* t (* c j))
(if (<= x -1.1e-117)
(* b (* a i))
(if (<= x -1.15e-200)
(* c (- 0.0 (* z b)))
(if (<= x 0.0074) (* j (* y (- 0.0 i))) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * (x * y);
double tmp;
if (x <= -5.5e+60) {
tmp = t_1;
} else if (x <= -2.3e-65) {
tmp = t * (c * j);
} else if (x <= -1.1e-117) {
tmp = b * (a * i);
} else if (x <= -1.15e-200) {
tmp = c * (0.0 - (z * b));
} else if (x <= 0.0074) {
tmp = j * (y * (0.0 - i));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = z * (x * y)
if (x <= (-5.5d+60)) then
tmp = t_1
else if (x <= (-2.3d-65)) then
tmp = t * (c * j)
else if (x <= (-1.1d-117)) then
tmp = b * (a * i)
else if (x <= (-1.15d-200)) then
tmp = c * (0.0d0 - (z * b))
else if (x <= 0.0074d0) then
tmp = j * (y * (0.0d0 - i))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * (x * y);
double tmp;
if (x <= -5.5e+60) {
tmp = t_1;
} else if (x <= -2.3e-65) {
tmp = t * (c * j);
} else if (x <= -1.1e-117) {
tmp = b * (a * i);
} else if (x <= -1.15e-200) {
tmp = c * (0.0 - (z * b));
} else if (x <= 0.0074) {
tmp = j * (y * (0.0 - i));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if x <= -5.5e+60: tmp = t_1 elif x <= -2.3e-65: tmp = t * (c * j) elif x <= -1.1e-117: tmp = b * (a * i) elif x <= -1.15e-200: tmp = c * (0.0 - (z * b)) elif x <= 0.0074: tmp = j * (y * (0.0 - i)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -5.5e+60) tmp = t_1; elseif (x <= -2.3e-65) tmp = Float64(t * Float64(c * j)); elseif (x <= -1.1e-117) tmp = Float64(b * Float64(a * i)); elseif (x <= -1.15e-200) tmp = Float64(c * Float64(0.0 - Float64(z * b))); elseif (x <= 0.0074) tmp = Float64(j * Float64(y * Float64(0.0 - i))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (x <= -5.5e+60) tmp = t_1; elseif (x <= -2.3e-65) tmp = t * (c * j); elseif (x <= -1.1e-117) tmp = b * (a * i); elseif (x <= -1.15e-200) tmp = c * (0.0 - (z * b)); elseif (x <= 0.0074) tmp = j * (y * (0.0 - i)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -5.5e+60], t$95$1, If[LessEqual[x, -2.3e-65], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.1e-117], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.15e-200], N[(c * N[(0.0 - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.0074], N[(j * N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -5.5 \cdot 10^{+60}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -2.3 \cdot 10^{-65}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;x \leq -1.1 \cdot 10^{-117}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;x \leq -1.15 \cdot 10^{-200}:\\
\;\;\;\;c \cdot \left(0 - z \cdot b\right)\\
\mathbf{elif}\;x \leq 0.0074:\\
\;\;\;\;j \cdot \left(y \cdot \left(0 - i\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -5.5000000000000001e60 or 0.0074000000000000003 < x Initial program 74.4%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6465.4
Simplified65.4%
Taylor expanded in c around 0
*-lowering-*.f6454.7
Simplified54.7%
if -5.5000000000000001e60 < x < -2.3e-65Initial program 64.4%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.4
Simplified64.4%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6455.3
Simplified55.3%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6433.7
Simplified33.7%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6443.2
Applied egg-rr43.2%
if -2.3e-65 < x < -1.1000000000000001e-117Initial program 99.9%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6482.6
Simplified82.6%
Taylor expanded in j around 0
*-lowering-*.f64N/A
*-lowering-*.f6456.3
Simplified56.3%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6473.0
Applied egg-rr73.0%
if -1.1000000000000001e-117 < x < -1.15000000000000004e-200Initial program 72.7%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6467.1
Simplified67.1%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6472.5
Simplified72.5%
Taylor expanded in t around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.0
Simplified67.0%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.6
Simplified67.6%
if -1.15000000000000004e-200 < x < 0.0074000000000000003Initial program 71.7%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6465.2
Simplified65.2%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6458.3
Simplified58.3%
Taylor expanded in t around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6449.1
Simplified49.1%
Taylor expanded in b around 0
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6430.7
Simplified30.7%
Final simplification45.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (- (* y z) (* t a)))))
(if (<= x -9.4e+123)
t_1
(if (<= x 4.5e+125)
(- (* j (- (* t c) (* y i))) (* c (* z b)))
(if (<= x 3.2e+218) t_1 (* z (fma c (- 0.0 b) (* x y))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * ((y * z) - (t * a));
double tmp;
if (x <= -9.4e+123) {
tmp = t_1;
} else if (x <= 4.5e+125) {
tmp = (j * ((t * c) - (y * i))) - (c * (z * b));
} else if (x <= 3.2e+218) {
tmp = t_1;
} else {
tmp = z * fma(c, (0.0 - b), (x * y));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(x * Float64(Float64(y * z) - Float64(t * a))) tmp = 0.0 if (x <= -9.4e+123) tmp = t_1; elseif (x <= 4.5e+125) tmp = Float64(Float64(j * Float64(Float64(t * c) - Float64(y * i))) - Float64(c * Float64(z * b))); elseif (x <= 3.2e+218) tmp = t_1; else tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -9.4e+123], t$95$1, If[LessEqual[x, 4.5e+125], N[(N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.2e+218], t$95$1, N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{if}\;x \leq -9.4 \cdot 10^{+123}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 4.5 \cdot 10^{+125}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right) - c \cdot \left(z \cdot b\right)\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{+218}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\end{array}
\end{array}
if x < -9.39999999999999958e123 or 4.5e125 < x < 3.19999999999999987e218Initial program 74.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6484.8
Simplified84.8%
if -9.39999999999999958e123 < x < 4.5e125Initial program 74.9%
Taylor expanded in c around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6461.4
Simplified61.4%
if 3.19999999999999987e218 < x Initial program 49.7%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6483.3
Simplified83.3%
sub0-negN/A
neg-lowering-neg.f6483.3
Applied egg-rr83.3%
Final simplification67.7%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (* x y))))
(if (<= x -4e+59)
t_1
(if (<= x -1.25e-65)
(* t (* c j))
(if (<= x -1.05e-117)
(* b (* a i))
(if (<= x 9.2e-298)
(* c (- 0.0 (* z b)))
(if (<= x 2.3e-85) (* c (* t 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 = z * (x * y);
double tmp;
if (x <= -4e+59) {
tmp = t_1;
} else if (x <= -1.25e-65) {
tmp = t * (c * j);
} else if (x <= -1.05e-117) {
tmp = b * (a * i);
} else if (x <= 9.2e-298) {
tmp = c * (0.0 - (z * b));
} else if (x <= 2.3e-85) {
tmp = c * (t * 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 = z * (x * y)
if (x <= (-4d+59)) then
tmp = t_1
else if (x <= (-1.25d-65)) then
tmp = t * (c * j)
else if (x <= (-1.05d-117)) then
tmp = b * (a * i)
else if (x <= 9.2d-298) then
tmp = c * (0.0d0 - (z * b))
else if (x <= 2.3d-85) then
tmp = c * (t * 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 = z * (x * y);
double tmp;
if (x <= -4e+59) {
tmp = t_1;
} else if (x <= -1.25e-65) {
tmp = t * (c * j);
} else if (x <= -1.05e-117) {
tmp = b * (a * i);
} else if (x <= 9.2e-298) {
tmp = c * (0.0 - (z * b));
} else if (x <= 2.3e-85) {
tmp = c * (t * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if x <= -4e+59: tmp = t_1 elif x <= -1.25e-65: tmp = t * (c * j) elif x <= -1.05e-117: tmp = b * (a * i) elif x <= 9.2e-298: tmp = c * (0.0 - (z * b)) elif x <= 2.3e-85: tmp = c * (t * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -4e+59) tmp = t_1; elseif (x <= -1.25e-65) tmp = Float64(t * Float64(c * j)); elseif (x <= -1.05e-117) tmp = Float64(b * Float64(a * i)); elseif (x <= 9.2e-298) tmp = Float64(c * Float64(0.0 - Float64(z * b))); elseif (x <= 2.3e-85) tmp = Float64(c * Float64(t * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (x <= -4e+59) tmp = t_1; elseif (x <= -1.25e-65) tmp = t * (c * j); elseif (x <= -1.05e-117) tmp = b * (a * i); elseif (x <= 9.2e-298) tmp = c * (0.0 - (z * b)); elseif (x <= 2.3e-85) tmp = c * (t * 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[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4e+59], t$95$1, If[LessEqual[x, -1.25e-65], N[(t * N[(c * j), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -1.05e-117], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.2e-298], N[(c * N[(0.0 - N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.3e-85], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -4 \cdot 10^{+59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -1.25 \cdot 10^{-65}:\\
\;\;\;\;t \cdot \left(c \cdot j\right)\\
\mathbf{elif}\;x \leq -1.05 \cdot 10^{-117}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{elif}\;x \leq 9.2 \cdot 10^{-298}:\\
\;\;\;\;c \cdot \left(0 - z \cdot b\right)\\
\mathbf{elif}\;x \leq 2.3 \cdot 10^{-85}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.99999999999999989e59 or 2.3e-85 < x Initial program 74.5%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6460.4
Simplified60.4%
Taylor expanded in c around 0
*-lowering-*.f6448.0
Simplified48.0%
if -3.99999999999999989e59 < x < -1.24999999999999996e-65Initial program 64.4%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.4
Simplified64.4%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6455.3
Simplified55.3%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6433.7
Simplified33.7%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6443.2
Applied egg-rr43.2%
if -1.24999999999999996e-65 < x < -1.05e-117Initial program 99.9%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6482.6
Simplified82.6%
Taylor expanded in j around 0
*-lowering-*.f64N/A
*-lowering-*.f6456.3
Simplified56.3%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6473.0
Applied egg-rr73.0%
if -1.05e-117 < x < 9.2000000000000003e-298Initial program 65.2%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6457.1
Simplified57.1%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.3
Simplified63.3%
Taylor expanded in t around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6453.4
Simplified53.4%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.9
Simplified43.9%
if 9.2000000000000003e-298 < x < 2.3e-85Initial program 76.8%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6471.0
Simplified71.0%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6465.6
Simplified65.6%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6435.1
Simplified35.1%
Final simplification45.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- 0.0 y) (* a b)))))
(if (<= i -1.8e+139)
t_1
(if (<= i -2.05e-12)
(* j (fma c t (* y (- 0.0 i))))
(if (<= i 1.2e+69) (* z (fma c (- 0.0 b) (* x y))) 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 = i * fma(j, (0.0 - y), (a * b));
double tmp;
if (i <= -1.8e+139) {
tmp = t_1;
} else if (i <= -2.05e-12) {
tmp = j * fma(c, t, (y * (0.0 - i)));
} else if (i <= 1.2e+69) {
tmp = z * fma(c, (0.0 - b), (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))) tmp = 0.0 if (i <= -1.8e+139) tmp = t_1; elseif (i <= -2.05e-12) tmp = Float64(j * fma(c, t, Float64(y * Float64(0.0 - i)))); elseif (i <= 1.2e+69) tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.8e+139], t$95$1, If[LessEqual[i, -2.05e-12], N[(j * N[(c * t + N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.2e+69], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{if}\;i \leq -1.8 \cdot 10^{+139}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -2.05 \cdot 10^{-12}:\\
\;\;\;\;j \cdot \mathsf{fma}\left(c, t, y \cdot \left(0 - i\right)\right)\\
\mathbf{elif}\;i \leq 1.2 \cdot 10^{+69}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.79999999999999993e139 or 1.2000000000000001e69 < i Initial program 73.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6472.5
Simplified72.5%
sub0-negN/A
neg-lowering-neg.f6472.5
Applied egg-rr72.5%
if -1.79999999999999993e139 < i < -2.04999999999999995e-12Initial program 69.7%
Taylor expanded in j around inf
*-lowering-*.f64N/A
sub-negN/A
accelerator-lowering-fma.f64N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6452.8
Simplified52.8%
if -2.04999999999999995e-12 < i < 1.2000000000000001e69Initial program 75.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6458.0
Simplified58.0%
sub0-negN/A
neg-lowering-neg.f6458.0
Applied egg-rr58.0%
Final simplification62.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- 0.0 y) (* a b)))))
(if (<= i -5.5e+134)
t_1
(if (<= i -3.9e+83)
(* c (fma b (- 0.0 z) (* t j)))
(if (<= i 2.5e+68) (* z (fma c (- 0.0 b) (* x y))) 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 = i * fma(j, (0.0 - y), (a * b));
double tmp;
if (i <= -5.5e+134) {
tmp = t_1;
} else if (i <= -3.9e+83) {
tmp = c * fma(b, (0.0 - z), (t * j));
} else if (i <= 2.5e+68) {
tmp = z * fma(c, (0.0 - b), (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))) tmp = 0.0 if (i <= -5.5e+134) tmp = t_1; elseif (i <= -3.9e+83) tmp = Float64(c * fma(b, Float64(0.0 - z), Float64(t * j))); elseif (i <= 2.5e+68) tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -5.5e+134], t$95$1, If[LessEqual[i, -3.9e+83], N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.5e+68], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{if}\;i \leq -5.5 \cdot 10^{+134}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -3.9 \cdot 10^{+83}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(b, 0 - z, t \cdot j\right)\\
\mathbf{elif}\;i \leq 2.5 \cdot 10^{+68}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -5.4999999999999999e134 or 2.5000000000000002e68 < i Initial program 71.0%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6472.3
Simplified72.3%
sub0-negN/A
neg-lowering-neg.f6472.3
Applied egg-rr72.3%
if -5.4999999999999999e134 < i < -3.9000000000000002e83Initial program 60.0%
Taylor expanded in c around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6490.1
Simplified90.1%
if -3.9000000000000002e83 < i < 2.5000000000000002e68Initial program 76.2%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6454.1
Simplified54.1%
sub0-negN/A
neg-lowering-neg.f6454.1
Applied egg-rr54.1%
Final simplification62.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (fma i a (- 0.0 (* z c))))))
(if (<= b -1.7e-41)
t_1
(if (<= b 2.3e-131)
(* x (- (* y z) (* t a)))
(if (<= b 9e+50) (* t (- (* c j) (* x a))) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * fma(i, a, (0.0 - (z * c)));
double tmp;
if (b <= -1.7e-41) {
tmp = t_1;
} else if (b <= 2.3e-131) {
tmp = x * ((y * z) - (t * a));
} else if (b <= 9e+50) {
tmp = t * ((c * j) - (x * a));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(i, a, Float64(0.0 - Float64(z * c)))) tmp = 0.0 if (b <= -1.7e-41) tmp = t_1; elseif (b <= 2.3e-131) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (b <= 9e+50) tmp = Float64(t * Float64(Float64(c * j) - Float64(x * a))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(i * a + N[(0.0 - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.7e-41], t$95$1, If[LessEqual[b, 2.3e-131], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9e+50], N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(i, a, 0 - z \cdot c\right)\\
\mathbf{if}\;b \leq -1.7 \cdot 10^{-41}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{-131}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;b \leq 9 \cdot 10^{+50}:\\
\;\;\;\;t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.6999999999999999e-41 or 9.00000000000000027e50 < b Initial program 73.2%
Taylor expanded in b around inf
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6464.0
Simplified64.0%
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
sub0-negN/A
distribute-lft-neg-outN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6464.0
Applied egg-rr64.0%
if -1.6999999999999999e-41 < b < 2.30000000000000022e-131Initial program 74.4%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6458.2
Simplified58.2%
if 2.30000000000000022e-131 < b < 9.00000000000000027e50Initial program 72.6%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
Applied egg-rr75.4%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.8
Simplified48.8%
Final simplification59.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* t (* c j))) (t_2 (* z (* x y))))
(if (<= x -1.05e+61)
t_2
(if (<= x -3.2e-65)
t_1
(if (<= x 3.2e-217) (* i (* a b)) (if (<= x 2.4e-85) 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 = t * (c * j);
double t_2 = z * (x * y);
double tmp;
if (x <= -1.05e+61) {
tmp = t_2;
} else if (x <= -3.2e-65) {
tmp = t_1;
} else if (x <= 3.2e-217) {
tmp = i * (a * b);
} else if (x <= 2.4e-85) {
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 = t * (c * j)
t_2 = z * (x * y)
if (x <= (-1.05d+61)) then
tmp = t_2
else if (x <= (-3.2d-65)) then
tmp = t_1
else if (x <= 3.2d-217) then
tmp = i * (a * b)
else if (x <= 2.4d-85) 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 = t * (c * j);
double t_2 = z * (x * y);
double tmp;
if (x <= -1.05e+61) {
tmp = t_2;
} else if (x <= -3.2e-65) {
tmp = t_1;
} else if (x <= 3.2e-217) {
tmp = i * (a * b);
} else if (x <= 2.4e-85) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = t * (c * j) t_2 = z * (x * y) tmp = 0 if x <= -1.05e+61: tmp = t_2 elif x <= -3.2e-65: tmp = t_1 elif x <= 3.2e-217: tmp = i * (a * b) elif x <= 2.4e-85: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(t * Float64(c * j)) t_2 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -1.05e+61) tmp = t_2; elseif (x <= -3.2e-65) tmp = t_1; elseif (x <= 3.2e-217) tmp = Float64(i * Float64(a * b)); elseif (x <= 2.4e-85) 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 = t * (c * j); t_2 = z * (x * y); tmp = 0.0; if (x <= -1.05e+61) tmp = t_2; elseif (x <= -3.2e-65) tmp = t_1; elseif (x <= 3.2e-217) tmp = i * (a * b); elseif (x <= 2.4e-85) 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[(t * N[(c * j), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.05e+61], t$95$2, If[LessEqual[x, -3.2e-65], t$95$1, If[LessEqual[x, 3.2e-217], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.4e-85], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j\right)\\
t_2 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -1.05 \cdot 10^{+61}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq -3.2 \cdot 10^{-65}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{-217}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;x \leq 2.4 \cdot 10^{-85}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if x < -1.0500000000000001e61 or 2.4000000000000001e-85 < x Initial program 74.5%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6460.4
Simplified60.4%
Taylor expanded in c around 0
*-lowering-*.f6448.0
Simplified48.0%
if -1.0500000000000001e61 < x < -3.1999999999999999e-65 or 3.2000000000000001e-217 < x < 2.4000000000000001e-85Initial program 68.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6466.1
Simplified66.1%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6462.7
Simplified62.7%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6438.5
Simplified38.5%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6442.2
Applied egg-rr42.2%
if -3.1999999999999999e-65 < x < 3.2000000000000001e-217Initial program 75.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6452.2
Simplified52.2%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Final simplification41.7%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= x -3.1e+121)
(* x (* y z))
(if (<= x -6.4e-214)
(* z (* b (- 0.0 c)))
(if (<= x 0.0235) (* i (* y (- 0.0 j))) (* z (* x y))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.1e+121) {
tmp = x * (y * z);
} else if (x <= -6.4e-214) {
tmp = z * (b * (0.0 - c));
} else if (x <= 0.0235) {
tmp = i * (y * (0.0 - j));
} else {
tmp = z * (x * y);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (x <= (-3.1d+121)) then
tmp = x * (y * z)
else if (x <= (-6.4d-214)) then
tmp = z * (b * (0.0d0 - c))
else if (x <= 0.0235d0) then
tmp = i * (y * (0.0d0 - j))
else
tmp = z * (x * y)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -3.1e+121) {
tmp = x * (y * z);
} else if (x <= -6.4e-214) {
tmp = z * (b * (0.0 - c));
} else if (x <= 0.0235) {
tmp = i * (y * (0.0 - j));
} else {
tmp = z * (x * y);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if x <= -3.1e+121: tmp = x * (y * z) elif x <= -6.4e-214: tmp = z * (b * (0.0 - c)) elif x <= 0.0235: tmp = i * (y * (0.0 - j)) else: tmp = z * (x * y) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -3.1e+121) tmp = Float64(x * Float64(y * z)); elseif (x <= -6.4e-214) tmp = Float64(z * Float64(b * Float64(0.0 - c))); elseif (x <= 0.0235) tmp = Float64(i * Float64(y * Float64(0.0 - j))); else tmp = Float64(z * Float64(x * y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (x <= -3.1e+121) tmp = x * (y * z); elseif (x <= -6.4e-214) tmp = z * (b * (0.0 - c)); elseif (x <= 0.0235) tmp = i * (y * (0.0 - j)); else tmp = z * (x * y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -3.1e+121], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -6.4e-214], N[(z * N[(b * N[(0.0 - c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.0235], N[(i * N[(y * N[(0.0 - j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3.1 \cdot 10^{+121}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;x \leq -6.4 \cdot 10^{-214}:\\
\;\;\;\;z \cdot \left(b \cdot \left(0 - c\right)\right)\\
\mathbf{elif}\;x \leq 0.0235:\\
\;\;\;\;i \cdot \left(y \cdot \left(0 - j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\end{array}
\end{array}
if x < -3.10000000000000008e121Initial program 68.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6486.7
Simplified86.7%
Taylor expanded in y around inf
*-commutativeN/A
*-lowering-*.f6470.6
Simplified70.6%
if -3.10000000000000008e121 < x < -6.40000000000000027e-214Initial program 73.9%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6448.3
Simplified48.3%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6442.9
Simplified42.9%
if -6.40000000000000027e-214 < x < 0.0235Initial program 72.6%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6451.3
Simplified51.3%
Taylor expanded in j around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6431.8
Simplified31.8%
if 0.0235 < x Initial program 79.9%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6456.6
Simplified56.6%
Taylor expanded in c around 0
*-lowering-*.f6443.0
Simplified43.0%
Final simplification43.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- 0.0 y) (* a b)))))
(if (<= i -1.9e-12)
t_1
(if (<= i 4.2e+67) (* z (fma c (- 0.0 b) (* x y))) 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 = i * fma(j, (0.0 - y), (a * b));
double tmp;
if (i <= -1.9e-12) {
tmp = t_1;
} else if (i <= 4.2e+67) {
tmp = z * fma(c, (0.0 - b), (x * y));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))) tmp = 0.0 if (i <= -1.9e-12) tmp = t_1; elseif (i <= 4.2e+67) tmp = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.9e-12], t$95$1, If[LessEqual[i, 4.2e+67], N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{if}\;i \leq -1.9 \cdot 10^{-12}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 4.2 \cdot 10^{+67}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.89999999999999998e-12 or 4.2000000000000003e67 < i Initial program 72.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6463.6
Simplified63.6%
sub0-negN/A
neg-lowering-neg.f6463.6
Applied egg-rr63.6%
if -1.89999999999999998e-12 < i < 4.2000000000000003e67Initial program 75.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6458.0
Simplified58.0%
sub0-negN/A
neg-lowering-neg.f6458.0
Applied egg-rr58.0%
Final simplification60.9%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* b (fma i a (- 0.0 (* z c)))))) (if (<= b -4.5e-52) t_1 (if (<= b 0.044) (* y (- (* x z) (* i j))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * fma(i, a, (0.0 - (z * c)));
double tmp;
if (b <= -4.5e-52) {
tmp = t_1;
} else if (b <= 0.044) {
tmp = y * ((x * z) - (i * j));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * fma(i, a, Float64(0.0 - Float64(z * c)))) tmp = 0.0 if (b <= -4.5e-52) tmp = t_1; elseif (b <= 0.044) tmp = Float64(y * Float64(Float64(x * z) - Float64(i * j))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(i * a + N[(0.0 - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4.5e-52], t$95$1, If[LessEqual[b, 0.044], N[(y * N[(N[(x * z), $MachinePrecision] - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \mathsf{fma}\left(i, a, 0 - z \cdot c\right)\\
\mathbf{if}\;b \leq -4.5 \cdot 10^{-52}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 0.044:\\
\;\;\;\;y \cdot \left(x \cdot z - i \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -4.5e-52 or 0.043999999999999997 < b Initial program 74.3%
Taylor expanded in b around inf
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6461.8
Simplified61.8%
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
sub0-negN/A
distribute-lft-neg-outN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6461.8
Applied egg-rr61.8%
if -4.5e-52 < b < 0.043999999999999997Initial program 72.5%
Taylor expanded in i around 0
Simplified81.9%
Taylor expanded in y around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6454.3
Simplified54.3%
Final simplification58.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* t (- (* c j) (* x a)))))
(if (<= t -5e+83)
t_1
(if (<= t 4.8e+36) (* i (fma j (- 0.0 y) (* 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 = t * ((c * j) - (x * a));
double tmp;
if (t <= -5e+83) {
tmp = t_1;
} else if (t <= 4.8e+36) {
tmp = i * fma(j, (0.0 - y), (a * b));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(t * Float64(Float64(c * j) - Float64(x * a))) tmp = 0.0 if (t <= -5e+83) tmp = t_1; elseif (t <= 4.8e+36) tmp = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(t * N[(N[(c * j), $MachinePrecision] - N[(x * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -5e+83], t$95$1, If[LessEqual[t, 4.8e+36], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(c \cdot j - x \cdot a\right)\\
\mathbf{if}\;t \leq -5 \cdot 10^{+83}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4.8 \cdot 10^{+36}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -5.00000000000000029e83 or 4.79999999999999985e36 < t Initial program 66.5%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
Applied egg-rr66.5%
Taylor expanded in t around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6460.9
Simplified60.9%
if -5.00000000000000029e83 < t < 4.79999999999999985e36Initial program 77.7%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6449.2
Simplified49.2%
sub0-negN/A
neg-lowering-neg.f6449.2
Applied egg-rr49.2%
Final simplification53.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (fma j (- 0.0 y) (* a b)))))
(if (<= j -1.65e+61)
t_1
(if (<= j 1.05e+91) (* b (fma i a (- 0.0 (* z c)))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = i * fma(j, (0.0 - y), (a * b));
double tmp;
if (j <= -1.65e+61) {
tmp = t_1;
} else if (j <= 1.05e+91) {
tmp = b * fma(i, a, (0.0 - (z * c)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))) tmp = 0.0 if (j <= -1.65e+61) tmp = t_1; elseif (j <= 1.05e+91) tmp = Float64(b * fma(i, a, Float64(0.0 - Float64(z * c)))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.65e+61], t$95$1, If[LessEqual[j, 1.05e+91], N[(b * N[(i * a + N[(0.0 - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{if}\;j \leq -1.65 \cdot 10^{+61}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq 1.05 \cdot 10^{+91}:\\
\;\;\;\;b \cdot \mathsf{fma}\left(i, a, 0 - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if j < -1.6499999999999999e61 or 1.05000000000000004e91 < j Initial program 73.2%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6457.4
Simplified57.4%
sub0-negN/A
neg-lowering-neg.f6457.4
Applied egg-rr57.4%
if -1.6499999999999999e61 < j < 1.05000000000000004e91Initial program 73.7%
Taylor expanded in b around inf
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6450.1
Simplified50.1%
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
sub0-negN/A
distribute-lft-neg-outN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6450.1
Applied egg-rr50.1%
Final simplification52.8%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= x -1.95e+146) (* x (* y z)) (if (<= x 2.3e+110) (* b (fma i a (- 0.0 (* z c)))) (* z (* x y)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (x <= -1.95e+146) {
tmp = x * (y * z);
} else if (x <= 2.3e+110) {
tmp = b * fma(i, a, (0.0 - (z * c)));
} else {
tmp = z * (x * y);
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (x <= -1.95e+146) tmp = Float64(x * Float64(y * z)); elseif (x <= 2.3e+110) tmp = Float64(b * fma(i, a, Float64(0.0 - Float64(z * c)))); else tmp = Float64(z * Float64(x * y)); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[x, -1.95e+146], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.3e+110], N[(b * N[(i * a + N[(0.0 - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.95 \cdot 10^{+146}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;x \leq 2.3 \cdot 10^{+110}:\\
\;\;\;\;b \cdot \mathsf{fma}\left(i, a, 0 - z \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(x \cdot y\right)\\
\end{array}
\end{array}
if x < -1.95e146Initial program 67.4%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6490.3
Simplified90.3%
Taylor expanded in y around inf
*-commutativeN/A
*-lowering-*.f6472.5
Simplified72.5%
if -1.95e146 < x < 2.3e110Initial program 74.5%
Taylor expanded in b around inf
sub-negN/A
remove-double-negN/A
mul-1-negN/A
distribute-neg-inN/A
+-commutativeN/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
sub-negN/A
mul-1-negN/A
distribute-neg-inN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6447.4
Simplified47.4%
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
sub0-negN/A
distribute-lft-neg-outN/A
neg-lowering-neg.f64N/A
*-commutativeN/A
*-lowering-*.f6447.9
Applied egg-rr47.9%
if 2.3e110 < x Initial program 75.6%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6459.5
Simplified59.5%
Taylor expanded in c around 0
*-lowering-*.f6445.7
Simplified45.7%
Final simplification51.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (* x y))))
(if (<= x -3.6e+58)
t_1
(if (<= x 2.65e-298)
(* i (* a b))
(if (<= x 6.3e-86) (* c (* t 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 = z * (x * y);
double tmp;
if (x <= -3.6e+58) {
tmp = t_1;
} else if (x <= 2.65e-298) {
tmp = i * (a * b);
} else if (x <= 6.3e-86) {
tmp = c * (t * 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 = z * (x * y)
if (x <= (-3.6d+58)) then
tmp = t_1
else if (x <= 2.65d-298) then
tmp = i * (a * b)
else if (x <= 6.3d-86) then
tmp = c * (t * 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 = z * (x * y);
double tmp;
if (x <= -3.6e+58) {
tmp = t_1;
} else if (x <= 2.65e-298) {
tmp = i * (a * b);
} else if (x <= 6.3e-86) {
tmp = c * (t * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = z * (x * y) tmp = 0 if x <= -3.6e+58: tmp = t_1 elif x <= 2.65e-298: tmp = i * (a * b) elif x <= 6.3e-86: tmp = c * (t * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * Float64(x * y)) tmp = 0.0 if (x <= -3.6e+58) tmp = t_1; elseif (x <= 2.65e-298) tmp = Float64(i * Float64(a * b)); elseif (x <= 6.3e-86) tmp = Float64(c * Float64(t * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = z * (x * y); tmp = 0.0; if (x <= -3.6e+58) tmp = t_1; elseif (x <= 2.65e-298) tmp = i * (a * b); elseif (x <= 6.3e-86) tmp = c * (t * 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[(z * N[(x * y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.6e+58], t$95$1, If[LessEqual[x, 2.65e-298], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 6.3e-86], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \left(x \cdot y\right)\\
\mathbf{if}\;x \leq -3.6 \cdot 10^{+58}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 2.65 \cdot 10^{-298}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;x \leq 6.3 \cdot 10^{-86}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.59999999999999996e58 or 6.2999999999999999e-86 < x Initial program 74.5%
Taylor expanded in z around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
+-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
neg-mul-1N/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6460.4
Simplified60.4%
Taylor expanded in c around 0
*-lowering-*.f6448.0
Simplified48.0%
if -3.59999999999999996e58 < x < 2.65000000000000001e-298Initial program 69.8%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6449.5
Simplified49.5%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6430.5
Simplified30.5%
if 2.65000000000000001e-298 < x < 6.2999999999999999e-86Initial program 76.8%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6471.0
Simplified71.0%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6465.6
Simplified65.6%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6435.1
Simplified35.1%
Final simplification40.0%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* x (* y z))))
(if (<= x -4e+59)
t_1
(if (<= x 7.4e-298)
(* i (* a b))
(if (<= x 1.45e-85) (* c (* t j)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (x <= -4e+59) {
tmp = t_1;
} else if (x <= 7.4e-298) {
tmp = i * (a * b);
} else if (x <= 1.45e-85) {
tmp = c * (t * j);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = x * (y * z)
if (x <= (-4d+59)) then
tmp = t_1
else if (x <= 7.4d-298) then
tmp = i * (a * b)
else if (x <= 1.45d-85) then
tmp = c * (t * j)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = x * (y * z);
double tmp;
if (x <= -4e+59) {
tmp = t_1;
} else if (x <= 7.4e-298) {
tmp = i * (a * b);
} else if (x <= 1.45e-85) {
tmp = c * (t * j);
} 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 x <= -4e+59: tmp = t_1 elif x <= 7.4e-298: tmp = i * (a * b) elif x <= 1.45e-85: tmp = c * (t * j) 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 (x <= -4e+59) tmp = t_1; elseif (x <= 7.4e-298) tmp = Float64(i * Float64(a * b)); elseif (x <= 1.45e-85) tmp = Float64(c * Float64(t * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = x * (y * z); tmp = 0.0; if (x <= -4e+59) tmp = t_1; elseif (x <= 7.4e-298) tmp = i * (a * b); elseif (x <= 1.45e-85) tmp = c * (t * j); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -4e+59], t$95$1, If[LessEqual[x, 7.4e-298], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.45e-85], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \left(y \cdot z\right)\\
\mathbf{if}\;x \leq -4 \cdot 10^{+59}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq 7.4 \cdot 10^{-298}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;x \leq 1.45 \cdot 10^{-85}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.99999999999999989e59 or 1.4500000000000001e-85 < x Initial program 74.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6463.7
Simplified63.7%
Taylor expanded in y around inf
*-commutativeN/A
*-lowering-*.f6447.1
Simplified47.1%
if -3.99999999999999989e59 < x < 7.3999999999999996e-298Initial program 69.8%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6449.5
Simplified49.5%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6430.5
Simplified30.5%
if 7.3999999999999996e-298 < x < 1.4500000000000001e-85Initial program 76.8%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6471.0
Simplified71.0%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6465.6
Simplified65.6%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6435.1
Simplified35.1%
Final simplification39.6%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* i (* a b)))) (if (<= a -4.4e-82) t_1 (if (<= a 1.7e-53) (* c (* t 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 = i * (a * b);
double tmp;
if (a <= -4.4e-82) {
tmp = t_1;
} else if (a <= 1.7e-53) {
tmp = c * (t * 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 = i * (a * b)
if (a <= (-4.4d-82)) then
tmp = t_1
else if (a <= 1.7d-53) then
tmp = c * (t * 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 = i * (a * b);
double tmp;
if (a <= -4.4e-82) {
tmp = t_1;
} else if (a <= 1.7e-53) {
tmp = c * (t * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = i * (a * b) tmp = 0 if a <= -4.4e-82: tmp = t_1 elif a <= 1.7e-53: tmp = c * (t * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(a * b)) tmp = 0.0 if (a <= -4.4e-82) tmp = t_1; elseif (a <= 1.7e-53) tmp = Float64(c * Float64(t * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = i * (a * b); tmp = 0.0; if (a <= -4.4e-82) tmp = t_1; elseif (a <= 1.7e-53) tmp = c * (t * 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[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -4.4e-82], t$95$1, If[LessEqual[a, 1.7e-53], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b\right)\\
\mathbf{if}\;a \leq -4.4 \cdot 10^{-82}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 1.7 \cdot 10^{-53}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.39999999999999971e-82 or 1.7e-53 < a Initial program 69.8%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6451.0
Simplified51.0%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6436.3
Simplified36.3%
if -4.39999999999999971e-82 < a < 1.7e-53Initial program 78.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.6
Simplified64.6%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6462.4
Simplified62.4%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6426.3
Simplified26.3%
Final simplification31.9%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* a (* b i)))) (if (<= a -8.4e-86) t_1 (if (<= a 8.2e-53) (* c (* t 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 = a * (b * i);
double tmp;
if (a <= -8.4e-86) {
tmp = t_1;
} else if (a <= 8.2e-53) {
tmp = c * (t * 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 = a * (b * i)
if (a <= (-8.4d-86)) then
tmp = t_1
else if (a <= 8.2d-53) then
tmp = c * (t * 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 = a * (b * i);
double tmp;
if (a <= -8.4e-86) {
tmp = t_1;
} else if (a <= 8.2e-53) {
tmp = c * (t * j);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = a * (b * i) tmp = 0 if a <= -8.4e-86: tmp = t_1 elif a <= 8.2e-53: tmp = c * (t * j) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(a * Float64(b * i)) tmp = 0.0 if (a <= -8.4e-86) tmp = t_1; elseif (a <= 8.2e-53) tmp = Float64(c * Float64(t * j)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); tmp = 0.0; if (a <= -8.4e-86) tmp = t_1; elseif (a <= 8.2e-53) tmp = c * (t * 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[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -8.4e-86], t$95$1, If[LessEqual[a, 8.2e-53], N[(c * N[(t * j), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
\mathbf{if}\;a \leq -8.4 \cdot 10^{-86}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 8.2 \cdot 10^{-53}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -8.4e-86 or 8.2000000000000001e-53 < a Initial program 69.8%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6451.0
Simplified51.0%
Taylor expanded in j around 0
*-lowering-*.f64N/A
*-lowering-*.f6434.1
Simplified34.1%
if -8.4e-86 < a < 8.2000000000000001e-53Initial program 78.1%
Taylor expanded in a around inf
*-lowering-*.f64N/A
sub-negN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.6
Simplified64.6%
Taylor expanded in c around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6462.4
Simplified62.4%
Taylor expanded in t around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6426.3
Simplified26.3%
(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 73.5%
Taylor expanded in i around inf
*-lowering-*.f64N/A
sub-negN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
mul-1-negN/A
remove-double-negN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6442.4
Simplified42.4%
Taylor expanded in j around 0
*-lowering-*.f64N/A
*-lowering-*.f6422.6
Simplified22.6%
(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 2024198
(FPCore (x y z t a b c i j)
:name "Linear.Matrix:det33 from linear-1.19.1.3"
:precision binary64
:alt
(! :herbie-platform default (if (< t -1015122364899489/125000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t -942510763643697/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (if (< t -238547917063487/3125000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))) (if (< t 10535888557455487/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) (+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (/ (* j (- (pow (* c t) 2) (pow (* i y) 2))) (+ (* c t) (* i y)))) (- (* x (- (* z y) (* a t))) (- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j))))))))
(+ (- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a)))) (* j (- (* c t) (* i y)))))