
(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 28 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
(fma i (fma j (- 0.0 y) (* a b)) (* 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))) + (b * ((a * i) - (z * c)))) + (j * ((t * c) - (y * i)));
double tmp;
if (t_1 <= ((double) INFINITY)) {
tmp = t_1;
} else {
tmp = fma(i, fma(j, (0.0 - y), (a * b)), (z * fma(c, (0.0 - b), (x * y))));
}
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 = fma(i, fma(j, Float64(0.0 - y), Float64(a * b)), 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[(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[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $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}:\\
\;\;\;\;\mathsf{fma}\left(i, \mathsf{fma}\left(j, 0 - y, a \cdot b\right), z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\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 93.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 z around 0
Simplified42.8%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified57.7%
Final simplification86.4%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(fma y (fma j (- 0.0 i) (* x z)) (* b (fma c (- 0.0 z) (* a i))))))
(if (<= b -1.7e+25)
t_1
(if (<= b 3.25e+75)
(fma
a
(fma t (- 0.0 x) (* b i))
(fma z (fma c (- 0.0 b) (* x y)) (* j (fma c t (* 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 = fma(y, fma(j, (0.0 - i), (x * z)), (b * fma(c, (0.0 - z), (a * i))));
double tmp;
if (b <= -1.7e+25) {
tmp = t_1;
} else if (b <= 3.25e+75) {
tmp = fma(a, fma(t, (0.0 - x), (b * i)), fma(z, fma(c, (0.0 - b), (x * y)), (j * fma(c, t, (y * (0.0 - i))))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(y, fma(j, Float64(0.0 - i), Float64(x * z)), Float64(b * fma(c, Float64(0.0 - z), Float64(a * i)))) tmp = 0.0 if (b <= -1.7e+25) tmp = t_1; elseif (b <= 3.25e+75) tmp = fma(a, fma(t, Float64(0.0 - x), Float64(b * i)), fma(z, fma(c, Float64(0.0 - b), Float64(x * y)), Float64(j * fma(c, t, Float64(y * Float64(0.0 - i)))))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = 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]}, If[LessEqual[b, -1.7e+25], t$95$1, If[LessEqual[b, 3.25e+75], N[(a * N[(t * N[(0.0 - x), $MachinePrecision] + N[(b * i), $MachinePrecision]), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision] + N[(j * N[(c * t + N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \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{if}\;b \leq -1.7 \cdot 10^{+25}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 3.25 \cdot 10^{+75}:\\
\;\;\;\;\mathsf{fma}\left(a, \mathsf{fma}\left(t, 0 - x, b \cdot i\right), \mathsf{fma}\left(z, \mathsf{fma}\left(c, 0 - b, x \cdot y\right), j \cdot \mathsf{fma}\left(c, t, y \cdot \left(0 - i\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.69999999999999992e25 or 3.2499999999999999e75 < b Initial program 70.8%
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
Simplified81.7%
if -1.69999999999999992e25 < b < 3.2499999999999999e75Initial program 77.4%
Taylor expanded in z around 0
Simplified85.2%
Final simplification83.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (fma j (- 0.0 y) (* a b))))
(if (<= i -1.1e+179)
(fma i t_1 (- 0.0 (* z (* b c))))
(if (<= i -1.02e-44)
(fma y (fma j (- 0.0 i) (* x z)) (* b (fma c (- 0.0 z) (* a i))))
(if (<= i 2.9e+15)
(fma c (fma b (- 0.0 z) (* t j)) (* x (- (* y z) (* t a))))
(fma i 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 = fma(j, (0.0 - y), (a * b));
double tmp;
if (i <= -1.1e+179) {
tmp = fma(i, t_1, (0.0 - (z * (b * c))));
} else if (i <= -1.02e-44) {
tmp = fma(y, fma(j, (0.0 - i), (x * z)), (b * fma(c, (0.0 - z), (a * i))));
} else if (i <= 2.9e+15) {
tmp = fma(c, fma(b, (0.0 - z), (t * j)), (x * ((y * z) - (t * a))));
} else {
tmp = fma(i, t_1, (z * fma(c, (0.0 - b), (x * y))));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(j, Float64(0.0 - y), Float64(a * b)) tmp = 0.0 if (i <= -1.1e+179) tmp = fma(i, t_1, Float64(0.0 - Float64(z * Float64(b * c)))); elseif (i <= -1.02e-44) tmp = fma(y, fma(j, Float64(0.0 - i), Float64(x * z)), Float64(b * fma(c, Float64(0.0 - z), Float64(a * i)))); elseif (i <= 2.9e+15) tmp = fma(c, fma(b, Float64(0.0 - z), Float64(t * j)), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); else tmp = fma(i, t_1, 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[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.1e+179], N[(i * t$95$1 + N[(0.0 - N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -1.02e-44], 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], If[LessEqual[i, 2.9e+15], N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * t$95$1 + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{if}\;i \leq -1.1 \cdot 10^{+179}:\\
\;\;\;\;\mathsf{fma}\left(i, t\_1, 0 - z \cdot \left(b \cdot c\right)\right)\\
\mathbf{elif}\;i \leq -1.02 \cdot 10^{-44}:\\
\;\;\;\;\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{elif}\;i \leq 2.9 \cdot 10^{+15}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(b, 0 - z, t \cdot j\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(i, t\_1, z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\end{array}
\end{array}
if i < -1.1e179Initial program 59.4%
Taylor expanded in z around 0
Simplified66.1%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified78.1%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6481.5
Simplified81.5%
if -1.1e179 < i < -1.0199999999999999e-44Initial program 70.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
Simplified77.0%
if -1.0199999999999999e-44 < i < 2.9e15Initial program 81.9%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-outN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified75.3%
if 2.9e15 < i Initial program 73.3%
Taylor expanded in z around 0
Simplified82.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified82.5%
Final simplification78.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(fma i (fma j (- 0.0 y) (* a b)) (* z (fma c (- 0.0 b) (* x y))))))
(if (<= i -9e+32)
t_1
(if (<= i 4.1e+16)
(fma c (fma b (- 0.0 z) (* t j)) (* x (- (* y z) (* t 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 = fma(i, fma(j, (0.0 - y), (a * b)), (z * fma(c, (0.0 - b), (x * y))));
double tmp;
if (i <= -9e+32) {
tmp = t_1;
} else if (i <= 4.1e+16) {
tmp = fma(c, fma(b, (0.0 - z), (t * j)), (x * ((y * z) - (t * a))));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = fma(i, fma(j, Float64(0.0 - y), Float64(a * b)), Float64(z * fma(c, Float64(0.0 - b), Float64(x * y)))) tmp = 0.0 if (i <= -9e+32) tmp = t_1; elseif (i <= 4.1e+16) tmp = fma(c, fma(b, Float64(0.0 - z), Float64(t * j)), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); 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] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -9e+32], t$95$1, If[LessEqual[i, 4.1e+16], N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(i, \mathsf{fma}\left(j, 0 - y, a \cdot b\right), z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\mathbf{if}\;i \leq -9 \cdot 10^{+32}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 4.1 \cdot 10^{+16}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(b, 0 - z, t \cdot j\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -9.0000000000000007e32 or 4.1e16 < i Initial program 69.9%
Taylor expanded in z around 0
Simplified75.5%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified79.0%
if -9.0000000000000007e32 < i < 4.1e16Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-outN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified71.7%
Final simplification75.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -6.1e+105)
(fma i (fma j (- 0.0 y) (* a b)) (- 0.0 (* z (* b c))))
(if (<= i 4e+88)
(fma c (fma b (- 0.0 z) (* t j)) (* x (- (* y z) (* t a))))
(* i (- (* a b) (* y j))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -6.1e+105) {
tmp = fma(i, fma(j, (0.0 - y), (a * b)), (0.0 - (z * (b * c))));
} else if (i <= 4e+88) {
tmp = fma(c, fma(b, (0.0 - z), (t * j)), (x * ((y * z) - (t * a))));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -6.1e+105) tmp = fma(i, fma(j, Float64(0.0 - y), Float64(a * b)), Float64(0.0 - Float64(z * Float64(b * c)))); elseif (i <= 4e+88) tmp = fma(c, fma(b, Float64(0.0 - z), Float64(t * j)), Float64(x * Float64(Float64(y * z) - Float64(t * a)))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -6.1e+105], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision] + N[(0.0 - N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 4e+88], N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision] + N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -6.1 \cdot 10^{+105}:\\
\;\;\;\;\mathsf{fma}\left(i, \mathsf{fma}\left(j, 0 - y, a \cdot b\right), 0 - z \cdot \left(b \cdot c\right)\right)\\
\mathbf{elif}\;i \leq 4 \cdot 10^{+88}:\\
\;\;\;\;\mathsf{fma}\left(c, \mathsf{fma}\left(b, 0 - z, t \cdot j\right), x \cdot \left(y \cdot z - t \cdot a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if i < -6.0999999999999996e105Initial program 61.9%
Taylor expanded in z around 0
Simplified59.8%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified72.5%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6477.0
Simplified77.0%
if -6.0999999999999996e105 < i < 3.99999999999999984e88Initial program 79.1%
Taylor expanded in i around 0
sub-negN/A
+-commutativeN/A
associate-+l+N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
distribute-lft-neg-outN/A
mul-1-negN/A
distribute-rgt-inN/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
Simplified69.6%
if 3.99999999999999984e88 < i Initial program 73.3%
Taylor expanded in z around 0
Simplified82.8%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified84.5%
Taylor expanded in i 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-*.f6475.4
Simplified75.4%
Final simplification72.1%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -8.2e+44)
(* i (* a b))
(if (<= b -4.5e-86)
(* x (* y z))
(if (<= b -3e-257)
(* a (* t (- 0.0 x)))
(if (<= b 1.4e-228)
(* y (- 0.0 (* i j)))
(if (<= b 26000.0)
(* y (* x z))
(if (<= b 2.7e+128) (* b (* a i)) (- 0.0 (* z (* b c))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -8.2e+44) {
tmp = i * (a * b);
} else if (b <= -4.5e-86) {
tmp = x * (y * z);
} else if (b <= -3e-257) {
tmp = a * (t * (0.0 - x));
} else if (b <= 1.4e-228) {
tmp = y * (0.0 - (i * j));
} else if (b <= 26000.0) {
tmp = y * (x * z);
} else if (b <= 2.7e+128) {
tmp = b * (a * i);
} else {
tmp = 0.0 - (z * (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-8.2d+44)) then
tmp = i * (a * b)
else if (b <= (-4.5d-86)) then
tmp = x * (y * z)
else if (b <= (-3d-257)) then
tmp = a * (t * (0.0d0 - x))
else if (b <= 1.4d-228) then
tmp = y * (0.0d0 - (i * j))
else if (b <= 26000.0d0) then
tmp = y * (x * z)
else if (b <= 2.7d+128) then
tmp = b * (a * i)
else
tmp = 0.0d0 - (z * (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -8.2e+44) {
tmp = i * (a * b);
} else if (b <= -4.5e-86) {
tmp = x * (y * z);
} else if (b <= -3e-257) {
tmp = a * (t * (0.0 - x));
} else if (b <= 1.4e-228) {
tmp = y * (0.0 - (i * j));
} else if (b <= 26000.0) {
tmp = y * (x * z);
} else if (b <= 2.7e+128) {
tmp = b * (a * i);
} else {
tmp = 0.0 - (z * (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -8.2e+44: tmp = i * (a * b) elif b <= -4.5e-86: tmp = x * (y * z) elif b <= -3e-257: tmp = a * (t * (0.0 - x)) elif b <= 1.4e-228: tmp = y * (0.0 - (i * j)) elif b <= 26000.0: tmp = y * (x * z) elif b <= 2.7e+128: tmp = b * (a * i) else: tmp = 0.0 - (z * (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -8.2e+44) tmp = Float64(i * Float64(a * b)); elseif (b <= -4.5e-86) tmp = Float64(x * Float64(y * z)); elseif (b <= -3e-257) tmp = Float64(a * Float64(t * Float64(0.0 - x))); elseif (b <= 1.4e-228) tmp = Float64(y * Float64(0.0 - Float64(i * j))); elseif (b <= 26000.0) tmp = Float64(y * Float64(x * z)); elseif (b <= 2.7e+128) tmp = Float64(b * Float64(a * i)); else tmp = Float64(0.0 - Float64(z * Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -8.2e+44) tmp = i * (a * b); elseif (b <= -4.5e-86) tmp = x * (y * z); elseif (b <= -3e-257) tmp = a * (t * (0.0 - x)); elseif (b <= 1.4e-228) tmp = y * (0.0 - (i * j)); elseif (b <= 26000.0) tmp = y * (x * z); elseif (b <= 2.7e+128) tmp = b * (a * i); else tmp = 0.0 - (z * (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -8.2e+44], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -4.5e-86], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -3e-257], N[(a * N[(t * N[(0.0 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.4e-228], N[(y * N[(0.0 - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 26000.0], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.7e+128], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -8.2 \cdot 10^{+44}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;b \leq -4.5 \cdot 10^{-86}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;b \leq -3 \cdot 10^{-257}:\\
\;\;\;\;a \cdot \left(t \cdot \left(0 - x\right)\right)\\
\mathbf{elif}\;b \leq 1.4 \cdot 10^{-228}:\\
\;\;\;\;y \cdot \left(0 - i \cdot j\right)\\
\mathbf{elif}\;b \leq 26000:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;b \leq 2.7 \cdot 10^{+128}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;0 - z \cdot \left(b \cdot c\right)\\
\end{array}
\end{array}
if b < -8.1999999999999993e44Initial program 72.6%
Taylor expanded in a 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-*.f6448.3
Simplified48.3%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6453.9
Applied egg-rr53.9%
if -8.1999999999999993e44 < b < -4.4999999999999998e-86Initial program 81.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in y around inf
*-lowering-*.f6438.4
Simplified38.4%
if -4.4999999999999998e-86 < b < -2.9999999999999999e-257Initial program 69.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6447.3
Simplified47.3%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/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--.f6439.0
Simplified39.0%
if -2.9999999999999999e-257 < b < 1.4000000000000001e-228Initial program 75.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--.f6457.1
Simplified57.1%
Taylor expanded in c around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.7
Simplified40.7%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6446.9
Applied egg-rr46.9%
if 1.4000000000000001e-228 < b < 26000Initial program 75.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.8
Simplified48.8%
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
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f6438.7
Simplified38.7%
if 26000 < b < 2.70000000000000001e128Initial program 79.4%
Taylor expanded in a 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-*.f6453.0
Simplified53.0%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6442.7
Applied egg-rr42.7%
if 2.70000000000000001e128 < b Initial program 72.9%
Taylor expanded in z around 0
Simplified60.5%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified70.0%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6452.0
Simplified52.0%
Final simplification44.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -6.6e+43)
(* i (* a b))
(if (<= b -1.26e-87)
(* x (* y z))
(if (<= b -2.05e-257)
(* a (* t (- 0.0 x)))
(if (<= b 2.3e-226)
(* j (* y (- 0.0 i)))
(if (<= b 450.0)
(* y (* x z))
(if (<= b 1.7e+128) (* b (* a i)) (- 0.0 (* z (* b c))))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -6.6e+43) {
tmp = i * (a * b);
} else if (b <= -1.26e-87) {
tmp = x * (y * z);
} else if (b <= -2.05e-257) {
tmp = a * (t * (0.0 - x));
} else if (b <= 2.3e-226) {
tmp = j * (y * (0.0 - i));
} else if (b <= 450.0) {
tmp = y * (x * z);
} else if (b <= 1.7e+128) {
tmp = b * (a * i);
} else {
tmp = 0.0 - (z * (b * c));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-6.6d+43)) then
tmp = i * (a * b)
else if (b <= (-1.26d-87)) then
tmp = x * (y * z)
else if (b <= (-2.05d-257)) then
tmp = a * (t * (0.0d0 - x))
else if (b <= 2.3d-226) then
tmp = j * (y * (0.0d0 - i))
else if (b <= 450.0d0) then
tmp = y * (x * z)
else if (b <= 1.7d+128) then
tmp = b * (a * i)
else
tmp = 0.0d0 - (z * (b * c))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -6.6e+43) {
tmp = i * (a * b);
} else if (b <= -1.26e-87) {
tmp = x * (y * z);
} else if (b <= -2.05e-257) {
tmp = a * (t * (0.0 - x));
} else if (b <= 2.3e-226) {
tmp = j * (y * (0.0 - i));
} else if (b <= 450.0) {
tmp = y * (x * z);
} else if (b <= 1.7e+128) {
tmp = b * (a * i);
} else {
tmp = 0.0 - (z * (b * c));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -6.6e+43: tmp = i * (a * b) elif b <= -1.26e-87: tmp = x * (y * z) elif b <= -2.05e-257: tmp = a * (t * (0.0 - x)) elif b <= 2.3e-226: tmp = j * (y * (0.0 - i)) elif b <= 450.0: tmp = y * (x * z) elif b <= 1.7e+128: tmp = b * (a * i) else: tmp = 0.0 - (z * (b * c)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -6.6e+43) tmp = Float64(i * Float64(a * b)); elseif (b <= -1.26e-87) tmp = Float64(x * Float64(y * z)); elseif (b <= -2.05e-257) tmp = Float64(a * Float64(t * Float64(0.0 - x))); elseif (b <= 2.3e-226) tmp = Float64(j * Float64(y * Float64(0.0 - i))); elseif (b <= 450.0) tmp = Float64(y * Float64(x * z)); elseif (b <= 1.7e+128) tmp = Float64(b * Float64(a * i)); else tmp = Float64(0.0 - Float64(z * Float64(b * c))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -6.6e+43) tmp = i * (a * b); elseif (b <= -1.26e-87) tmp = x * (y * z); elseif (b <= -2.05e-257) tmp = a * (t * (0.0 - x)); elseif (b <= 2.3e-226) tmp = j * (y * (0.0 - i)); elseif (b <= 450.0) tmp = y * (x * z); elseif (b <= 1.7e+128) tmp = b * (a * i); else tmp = 0.0 - (z * (b * c)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -6.6e+43], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.26e-87], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.05e-257], N[(a * N[(t * N[(0.0 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 2.3e-226], N[(j * N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 450.0], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.7e+128], N[(b * N[(a * i), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(z * N[(b * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6.6 \cdot 10^{+43}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;b \leq -1.26 \cdot 10^{-87}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;b \leq -2.05 \cdot 10^{-257}:\\
\;\;\;\;a \cdot \left(t \cdot \left(0 - x\right)\right)\\
\mathbf{elif}\;b \leq 2.3 \cdot 10^{-226}:\\
\;\;\;\;j \cdot \left(y \cdot \left(0 - i\right)\right)\\
\mathbf{elif}\;b \leq 450:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{elif}\;b \leq 1.7 \cdot 10^{+128}:\\
\;\;\;\;b \cdot \left(a \cdot i\right)\\
\mathbf{else}:\\
\;\;\;\;0 - z \cdot \left(b \cdot c\right)\\
\end{array}
\end{array}
if b < -6.6000000000000003e43Initial program 72.6%
Taylor expanded in a 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-*.f6448.3
Simplified48.3%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6453.9
Applied egg-rr53.9%
if -6.6000000000000003e43 < b < -1.26000000000000009e-87Initial program 81.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in y around inf
*-lowering-*.f6438.4
Simplified38.4%
if -1.26000000000000009e-87 < b < -2.0499999999999998e-257Initial program 69.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6447.3
Simplified47.3%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/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--.f6439.0
Simplified39.0%
if -2.0499999999999998e-257 < b < 2.3e-226Initial program 75.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--.f6457.1
Simplified57.1%
Taylor expanded in c around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6446.9
Simplified46.9%
if 2.3e-226 < b < 450Initial program 75.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.8
Simplified48.8%
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
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6446.5
Simplified46.5%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f6438.7
Simplified38.7%
if 450 < b < 1.6999999999999999e128Initial program 79.4%
Taylor expanded in a 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-*.f6453.0
Simplified53.0%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6442.7
Applied egg-rr42.7%
if 1.6999999999999999e128 < b Initial program 72.9%
Taylor expanded in z around 0
Simplified60.5%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified70.0%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6452.0
Simplified52.0%
Final simplification44.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))) (t_2 (+ t_1 (* i (* a b)))))
(if (<= j -7e+213)
t_1
(if (<= j -2.6e-40)
t_2
(if (<= j 2.2e-50)
(fma i (* a b) (* z (fma c (- 0.0 b) (* x y))))
t_2)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double t_2 = t_1 + (i * (a * b));
double tmp;
if (j <= -7e+213) {
tmp = t_1;
} else if (j <= -2.6e-40) {
tmp = t_2;
} else if (j <= 2.2e-50) {
tmp = fma(i, (a * b), (z * fma(c, (0.0 - b), (x * y))));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) t_2 = Float64(t_1 + Float64(i * Float64(a * b))) tmp = 0.0 if (j <= -7e+213) tmp = t_1; elseif (j <= -2.6e-40) tmp = t_2; elseif (j <= 2.2e-50) tmp = fma(i, Float64(a * b), Float64(z * fma(c, Float64(0.0 - b), Float64(x * y)))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 + N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -7e+213], t$95$1, If[LessEqual[j, -2.6e-40], t$95$2, If[LessEqual[j, 2.2e-50], N[(i * N[(a * b), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
t_2 := t\_1 + i \cdot \left(a \cdot b\right)\\
\mathbf{if}\;j \leq -7 \cdot 10^{+213}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;j \leq -2.6 \cdot 10^{-40}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;j \leq 2.2 \cdot 10^{-50}:\\
\;\;\;\;\mathsf{fma}\left(i, a \cdot b, z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if j < -6.9999999999999994e213Initial program 67.8%
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--.f6488.2
Simplified88.2%
*-commutativeN/A
sub0-negN/A
cancel-sign-sub-invN/A
*-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6488.2
Applied egg-rr88.2%
if -6.9999999999999994e213 < j < -2.6000000000000001e-40 or 2.1999999999999999e-50 < j Initial program 81.5%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6469.0
Simplified69.0%
if -2.6000000000000001e-40 < j < 2.1999999999999999e-50Initial program 70.2%
Taylor expanded in z around 0
Simplified75.8%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified73.7%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6467.8
Simplified67.8%
Final simplification70.3%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= b -4e+17)
t_1
(if (<= b -1.85e-88)
(* x (* y z))
(if (<= b -2.35e-254)
(* a (* t (- 0.0 x)))
(if (<= b 1.95e-230)
(* y (- 0.0 (* i j)))
(if (<= b 9.8e-24) (* y (* x z)) t_1)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -4e+17) {
tmp = t_1;
} else if (b <= -1.85e-88) {
tmp = x * (y * z);
} else if (b <= -2.35e-254) {
tmp = a * (t * (0.0 - x));
} else if (b <= 1.95e-230) {
tmp = y * (0.0 - (i * j));
} else if (b <= 9.8e-24) {
tmp = y * (x * z);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (b <= (-4d+17)) then
tmp = t_1
else if (b <= (-1.85d-88)) then
tmp = x * (y * z)
else if (b <= (-2.35d-254)) then
tmp = a * (t * (0.0d0 - x))
else if (b <= 1.95d-230) then
tmp = y * (0.0d0 - (i * j))
else if (b <= 9.8d-24) then
tmp = y * (x * z)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -4e+17) {
tmp = t_1;
} else if (b <= -1.85e-88) {
tmp = x * (y * z);
} else if (b <= -2.35e-254) {
tmp = a * (t * (0.0 - x));
} else if (b <= 1.95e-230) {
tmp = y * (0.0 - (i * j));
} else if (b <= 9.8e-24) {
tmp = y * (x * z);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -4e+17: tmp = t_1 elif b <= -1.85e-88: tmp = x * (y * z) elif b <= -2.35e-254: tmp = a * (t * (0.0 - x)) elif b <= 1.95e-230: tmp = y * (0.0 - (i * j)) elif b <= 9.8e-24: tmp = y * (x * z) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -4e+17) tmp = t_1; elseif (b <= -1.85e-88) tmp = Float64(x * Float64(y * z)); elseif (b <= -2.35e-254) tmp = Float64(a * Float64(t * Float64(0.0 - x))); elseif (b <= 1.95e-230) tmp = Float64(y * Float64(0.0 - Float64(i * j))); elseif (b <= 9.8e-24) tmp = Float64(y * Float64(x * z)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -4e+17) tmp = t_1; elseif (b <= -1.85e-88) tmp = x * (y * z); elseif (b <= -2.35e-254) tmp = a * (t * (0.0 - x)); elseif (b <= 1.95e-230) tmp = y * (0.0 - (i * j)); elseif (b <= 9.8e-24) tmp = y * (x * z); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -4e+17], t$95$1, If[LessEqual[b, -1.85e-88], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -2.35e-254], N[(a * N[(t * N[(0.0 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.95e-230], N[(y * N[(0.0 - N[(i * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 9.8e-24], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -4 \cdot 10^{+17}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq -1.85 \cdot 10^{-88}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;b \leq -2.35 \cdot 10^{-254}:\\
\;\;\;\;a \cdot \left(t \cdot \left(0 - x\right)\right)\\
\mathbf{elif}\;b \leq 1.95 \cdot 10^{-230}:\\
\;\;\;\;y \cdot \left(0 - i \cdot j\right)\\
\mathbf{elif}\;b \leq 9.8 \cdot 10^{-24}:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -4e17 or 9.8000000000000002e-24 < b Initial program 74.1%
Taylor expanded in z around 0
Simplified70.0%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified70.4%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6465.8
Simplified65.8%
if -4e17 < b < -1.8499999999999999e-88Initial program 84.8%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6447.3
Simplified47.3%
Taylor expanded in y around inf
*-lowering-*.f6439.2
Simplified39.2%
if -1.8499999999999999e-88 < b < -2.35000000000000013e-254Initial program 69.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6447.3
Simplified47.3%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/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--.f6439.0
Simplified39.0%
if -2.35000000000000013e-254 < b < 1.9500000000000001e-230Initial program 75.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--.f6457.1
Simplified57.1%
Taylor expanded in c around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.7
Simplified40.7%
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6446.9
Applied egg-rr46.9%
if 1.9500000000000001e-230 < b < 9.8000000000000002e-24Initial program 75.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.5
Simplified48.5%
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
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6448.6
Simplified48.6%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f6440.0
Simplified40.0%
Final simplification52.9%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.1e+33)
(* i (fma j (- 0.0 y) (* a b)))
(if (<= i -3.4e-99)
(* x (* z (- y (/ (* t a) z))))
(if (<= i 5.2e-84)
(* c (fma j t (* z (- 0.0 b))))
(if (<= i 2.9e+20)
(- 0.0 (fma (* t a) x (* i (* y j))))
(* i (- (* a b) (* y j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.1e+33) {
tmp = i * fma(j, (0.0 - y), (a * b));
} else if (i <= -3.4e-99) {
tmp = x * (z * (y - ((t * a) / z)));
} else if (i <= 5.2e-84) {
tmp = c * fma(j, t, (z * (0.0 - b)));
} else if (i <= 2.9e+20) {
tmp = 0.0 - fma((t * a), x, (i * (y * j)));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.1e+33) tmp = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))); elseif (i <= -3.4e-99) tmp = Float64(x * Float64(z * Float64(y - Float64(Float64(t * a) / z)))); elseif (i <= 5.2e-84) tmp = Float64(c * fma(j, t, Float64(z * Float64(0.0 - b)))); elseif (i <= 2.9e+20) tmp = Float64(0.0 - fma(Float64(t * a), x, Float64(i * Float64(y * j)))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.1e+33], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -3.4e-99], N[(x * N[(z * N[(y - N[(N[(t * a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 5.2e-84], N[(c * N[(j * t + N[(z * N[(0.0 - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.9e+20], N[(0.0 - N[(N[(t * a), $MachinePrecision] * x + N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.1 \cdot 10^{+33}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{elif}\;i \leq -3.4 \cdot 10^{-99}:\\
\;\;\;\;x \cdot \left(z \cdot \left(y - \frac{t \cdot a}{z}\right)\right)\\
\mathbf{elif}\;i \leq 5.2 \cdot 10^{-84}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(0 - b\right)\right)\\
\mathbf{elif}\;i \leq 2.9 \cdot 10^{+20}:\\
\;\;\;\;0 - \mathsf{fma}\left(t \cdot a, x, i \cdot \left(y \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if i < -1.09999999999999997e33Initial program 66.3%
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-*.f6466.8
Simplified66.8%
if -1.09999999999999997e33 < i < -3.40000000000000007e-99Initial program 70.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0
Simplified55.0%
Taylor expanded in z around inf
*-lowering-*.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6455.1
Simplified55.1%
if -3.40000000000000007e-99 < i < 5.2e-84Initial program 82.3%
Taylor expanded in z around 0
Simplified80.1%
Taylor expanded in c around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6459.5
Simplified59.5%
if 5.2e-84 < i < 2.9e20Initial program 81.1%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6475.5
Simplified75.5%
Taylor expanded in c around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6475.9
Simplified75.9%
if 2.9e20 < i Initial program 73.3%
Taylor expanded in z around 0
Simplified82.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified82.5%
Taylor expanded in i 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-*.f6470.0
Simplified70.0%
Final simplification64.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -4.2e+33)
(* i (fma j (- 0.0 y) (* a b)))
(if (<= i -8.2e-103)
(* x (- (* y z) (* t a)))
(if (<= i 2.6e-83)
(* c (fma j t (* z (- 0.0 b))))
(if (<= i 1.32e+16)
(- 0.0 (fma (* t a) x (* i (* y j))))
(* i (- (* a b) (* y j))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -4.2e+33) {
tmp = i * fma(j, (0.0 - y), (a * b));
} else if (i <= -8.2e-103) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 2.6e-83) {
tmp = c * fma(j, t, (z * (0.0 - b)));
} else if (i <= 1.32e+16) {
tmp = 0.0 - fma((t * a), x, (i * (y * j)));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -4.2e+33) tmp = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))); elseif (i <= -8.2e-103) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (i <= 2.6e-83) tmp = Float64(c * fma(j, t, Float64(z * Float64(0.0 - b)))); elseif (i <= 1.32e+16) tmp = Float64(0.0 - fma(Float64(t * a), x, Float64(i * Float64(y * j)))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -4.2e+33], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -8.2e-103], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 2.6e-83], N[(c * N[(j * t + N[(z * N[(0.0 - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 1.32e+16], N[(0.0 - N[(N[(t * a), $MachinePrecision] * x + N[(i * N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -4.2 \cdot 10^{+33}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{elif}\;i \leq -8.2 \cdot 10^{-103}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;i \leq 2.6 \cdot 10^{-83}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(0 - b\right)\right)\\
\mathbf{elif}\;i \leq 1.32 \cdot 10^{+16}:\\
\;\;\;\;0 - \mathsf{fma}\left(t \cdot a, x, i \cdot \left(y \cdot j\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if i < -4.2000000000000001e33Initial program 66.3%
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-*.f6466.8
Simplified66.8%
if -4.2000000000000001e33 < i < -8.19999999999999992e-103Initial program 70.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0
Simplified55.0%
if -8.19999999999999992e-103 < i < 2.60000000000000009e-83Initial program 82.3%
Taylor expanded in z around 0
Simplified80.1%
Taylor expanded in c around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6459.5
Simplified59.5%
if 2.60000000000000009e-83 < i < 1.32e16Initial program 81.1%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6475.5
Simplified75.5%
Taylor expanded in c around 0
distribute-lft-outN/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*r*N/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6475.9
Simplified75.9%
if 1.32e16 < i Initial program 73.3%
Taylor expanded in z around 0
Simplified82.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified82.5%
Taylor expanded in i 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-*.f6470.0
Simplified70.0%
Final simplification64.2%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= j -2.4e+149)
(* j (- (* t c) (* y i)))
(if (<= j -1.95e+15)
(* i (fma j (- 0.0 y) (* a b)))
(if (<= j 6.8e-32)
(fma i (* a b) (* z (fma c (- 0.0 b) (* x y))))
(* j (* i (fma c (/ t i) (- 0.0 y))))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (j <= -2.4e+149) {
tmp = j * ((t * c) - (y * i));
} else if (j <= -1.95e+15) {
tmp = i * fma(j, (0.0 - y), (a * b));
} else if (j <= 6.8e-32) {
tmp = fma(i, (a * b), (z * fma(c, (0.0 - b), (x * y))));
} else {
tmp = j * (i * fma(c, (t / i), (0.0 - y)));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (j <= -2.4e+149) tmp = Float64(j * Float64(Float64(t * c) - Float64(y * i))); elseif (j <= -1.95e+15) tmp = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))); elseif (j <= 6.8e-32) tmp = fma(i, Float64(a * b), Float64(z * fma(c, Float64(0.0 - b), Float64(x * y)))); else tmp = Float64(j * Float64(i * fma(c, Float64(t / i), Float64(0.0 - y)))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[j, -2.4e+149], N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, -1.95e+15], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 6.8e-32], N[(i * N[(a * b), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(j * N[(i * N[(c * N[(t / i), $MachinePrecision] + N[(0.0 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;j \leq -2.4 \cdot 10^{+149}:\\
\;\;\;\;j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{elif}\;j \leq -1.95 \cdot 10^{+15}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{elif}\;j \leq 6.8 \cdot 10^{-32}:\\
\;\;\;\;\mathsf{fma}\left(i, a \cdot b, z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(i \cdot \mathsf{fma}\left(c, \frac{t}{i}, 0 - y\right)\right)\\
\end{array}
\end{array}
if j < -2.40000000000000012e149Initial program 73.2%
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--.f6480.3
Simplified80.3%
*-commutativeN/A
sub0-negN/A
cancel-sign-sub-invN/A
*-commutativeN/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6480.3
Applied egg-rr80.3%
if -2.40000000000000012e149 < j < -1.95e15Initial program 90.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-*.f6468.6
Simplified68.6%
if -1.95e15 < j < 6.79999999999999956e-32Initial program 72.1%
Taylor expanded in z around 0
Simplified77.9%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified75.3%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6467.1
Simplified67.1%
if 6.79999999999999956e-32 < j Initial program 75.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--.f6457.5
Simplified57.5%
Taylor expanded in i around inf
+-commutativeN/A
mul-1-negN/A
sub-negN/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--.f6459.2
Simplified59.2%
Final simplification67.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= j -3.8e-53)
(- t_1 (* c (* z b)))
(if (<= j 6.5e-53)
(fma i (* a b) (* z (fma c (- 0.0 b) (* x y))))
(+ t_1 (* i (* a b)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (j <= -3.8e-53) {
tmp = t_1 - (c * (z * b));
} else if (j <= 6.5e-53) {
tmp = fma(i, (a * b), (z * fma(c, (0.0 - b), (x * y))));
} else {
tmp = t_1 + (i * (a * b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -3.8e-53) tmp = Float64(t_1 - Float64(c * Float64(z * b))); elseif (j <= 6.5e-53) tmp = fma(i, Float64(a * b), Float64(z * fma(c, Float64(0.0 - b), Float64(x * y)))); else tmp = Float64(t_1 + Float64(i * Float64(a * b))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -3.8e-53], N[(t$95$1 - N[(c * N[(z * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 6.5e-53], N[(i * N[(a * b), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -3.8 \cdot 10^{-53}:\\
\;\;\;\;t\_1 - c \cdot \left(z \cdot b\right)\\
\mathbf{elif}\;j \leq 6.5 \cdot 10^{-53}:\\
\;\;\;\;\mathsf{fma}\left(i, a \cdot b, z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 + i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if j < -3.7999999999999998e-53Initial program 80.1%
Taylor expanded in c around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6473.0
Simplified73.0%
if -3.7999999999999998e-53 < j < 6.4999999999999997e-53Initial program 70.4%
Taylor expanded in z around 0
Simplified77.0%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified74.9%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6468.6
Simplified68.6%
if 6.4999999999999997e-53 < j Initial program 76.2%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.2
Simplified67.2%
Final simplification69.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* j (- (* t c) (* y i)))))
(if (<= j -1.55e-86)
(- t_1 (* a (* x t)))
(if (<= j 7.8e-51)
(fma i (* a b) (* z (fma c (- 0.0 b) (* x y))))
(+ t_1 (* i (* a b)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = j * ((t * c) - (y * i));
double tmp;
if (j <= -1.55e-86) {
tmp = t_1 - (a * (x * t));
} else if (j <= 7.8e-51) {
tmp = fma(i, (a * b), (z * fma(c, (0.0 - b), (x * y))));
} else {
tmp = t_1 + (i * (a * b));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(j * Float64(Float64(t * c) - Float64(y * i))) tmp = 0.0 if (j <= -1.55e-86) tmp = Float64(t_1 - Float64(a * Float64(x * t))); elseif (j <= 7.8e-51) tmp = fma(i, Float64(a * b), Float64(z * fma(c, Float64(0.0 - b), Float64(x * y)))); else tmp = Float64(t_1 + Float64(i * Float64(a * b))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(j * N[(N[(t * c), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[j, -1.55e-86], N[(t$95$1 - N[(a * N[(x * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[j, 7.8e-51], N[(i * N[(a * b), $MachinePrecision] + N[(z * N[(c * N[(0.0 - b), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 + N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := j \cdot \left(t \cdot c - y \cdot i\right)\\
\mathbf{if}\;j \leq -1.55 \cdot 10^{-86}:\\
\;\;\;\;t\_1 - a \cdot \left(x \cdot t\right)\\
\mathbf{elif}\;j \leq 7.8 \cdot 10^{-51}:\\
\;\;\;\;\mathsf{fma}\left(i, a \cdot b, z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1 + i \cdot \left(a \cdot b\right)\\
\end{array}
\end{array}
if j < -1.54999999999999994e-86Initial program 79.8%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f6467.5
Simplified67.5%
if -1.54999999999999994e-86 < j < 7.7999999999999995e-51Initial program 69.9%
Taylor expanded in z around 0
Simplified77.0%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified76.4%
Taylor expanded in j around 0
*-commutativeN/A
*-lowering-*.f6470.8
Simplified70.8%
if 7.7999999999999995e-51 < j Initial program 76.2%
Taylor expanded in i around inf
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.2
Simplified67.2%
Final simplification68.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -1.44e-8)
(* x (* y z))
(if (<= y 1.4e-267)
(* j (* t c))
(if (<= y 1.06e-128)
(* x (- 0.0 (* t a)))
(if (<= y 0.29) (* i (* a b)) (* j (* 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 (y <= -1.44e-8) {
tmp = x * (y * z);
} else if (y <= 1.4e-267) {
tmp = j * (t * c);
} else if (y <= 1.06e-128) {
tmp = x * (0.0 - (t * a));
} else if (y <= 0.29) {
tmp = i * (a * b);
} else {
tmp = j * (y * (0.0 - i));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-1.44d-8)) then
tmp = x * (y * z)
else if (y <= 1.4d-267) then
tmp = j * (t * c)
else if (y <= 1.06d-128) then
tmp = x * (0.0d0 - (t * a))
else if (y <= 0.29d0) then
tmp = i * (a * b)
else
tmp = j * (y * (0.0d0 - i))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -1.44e-8) {
tmp = x * (y * z);
} else if (y <= 1.4e-267) {
tmp = j * (t * c);
} else if (y <= 1.06e-128) {
tmp = x * (0.0 - (t * a));
} else if (y <= 0.29) {
tmp = i * (a * b);
} else {
tmp = j * (y * (0.0 - i));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -1.44e-8: tmp = x * (y * z) elif y <= 1.4e-267: tmp = j * (t * c) elif y <= 1.06e-128: tmp = x * (0.0 - (t * a)) elif y <= 0.29: tmp = i * (a * b) else: tmp = j * (y * (0.0 - i)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -1.44e-8) tmp = Float64(x * Float64(y * z)); elseif (y <= 1.4e-267) tmp = Float64(j * Float64(t * c)); elseif (y <= 1.06e-128) tmp = Float64(x * Float64(0.0 - Float64(t * a))); elseif (y <= 0.29) tmp = Float64(i * Float64(a * b)); else tmp = Float64(j * Float64(y * Float64(0.0 - i))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -1.44e-8) tmp = x * (y * z); elseif (y <= 1.4e-267) tmp = j * (t * c); elseif (y <= 1.06e-128) tmp = x * (0.0 - (t * a)); elseif (y <= 0.29) tmp = i * (a * b); else tmp = j * (y * (0.0 - i)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -1.44e-8], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.4e-267], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.06e-128], N[(x * N[(0.0 - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.29], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(j * N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.44 \cdot 10^{-8}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{-267}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;y \leq 1.06 \cdot 10^{-128}:\\
\;\;\;\;x \cdot \left(0 - t \cdot a\right)\\
\mathbf{elif}\;y \leq 0.29:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(y \cdot \left(0 - i\right)\right)\\
\end{array}
\end{array}
if y < -1.44e-8Initial program 69.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6444.8
Simplified44.8%
Taylor expanded in y around inf
*-lowering-*.f6438.4
Simplified38.4%
if -1.44e-8 < y < 1.40000000000000002e-267Initial program 78.3%
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--.f6436.4
Simplified36.4%
Taylor expanded in c around inf
*-lowering-*.f6433.1
Simplified33.1%
if 1.40000000000000002e-267 < y < 1.05999999999999995e-128Initial program 88.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6449.5
Simplified49.5%
Taylor expanded in y around 0
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6444.4
Simplified44.4%
if 1.05999999999999995e-128 < y < 0.28999999999999998Initial program 79.8%
Taylor expanded in a 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-*.f6455.4
Simplified55.4%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6441.5
Simplified41.5%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6447.0
Applied egg-rr47.0%
if 0.28999999999999998 < y Initial program 68.8%
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--.f6457.8
Simplified57.8%
Taylor expanded in c around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6447.9
Simplified47.9%
Final simplification41.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= y -9.5e-5)
(* x (* y z))
(if (<= y 1.36e-269)
(* j (* t c))
(if (<= y 9.2e-129)
(* a (* t (- 0.0 x)))
(if (<= y 0.29) (* i (* a b)) (* j (* 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 (y <= -9.5e-5) {
tmp = x * (y * z);
} else if (y <= 1.36e-269) {
tmp = j * (t * c);
} else if (y <= 9.2e-129) {
tmp = a * (t * (0.0 - x));
} else if (y <= 0.29) {
tmp = i * (a * b);
} else {
tmp = j * (y * (0.0 - i));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (y <= (-9.5d-5)) then
tmp = x * (y * z)
else if (y <= 1.36d-269) then
tmp = j * (t * c)
else if (y <= 9.2d-129) then
tmp = a * (t * (0.0d0 - x))
else if (y <= 0.29d0) then
tmp = i * (a * b)
else
tmp = j * (y * (0.0d0 - i))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (y <= -9.5e-5) {
tmp = x * (y * z);
} else if (y <= 1.36e-269) {
tmp = j * (t * c);
} else if (y <= 9.2e-129) {
tmp = a * (t * (0.0 - x));
} else if (y <= 0.29) {
tmp = i * (a * b);
} else {
tmp = j * (y * (0.0 - i));
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if y <= -9.5e-5: tmp = x * (y * z) elif y <= 1.36e-269: tmp = j * (t * c) elif y <= 9.2e-129: tmp = a * (t * (0.0 - x)) elif y <= 0.29: tmp = i * (a * b) else: tmp = j * (y * (0.0 - i)) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (y <= -9.5e-5) tmp = Float64(x * Float64(y * z)); elseif (y <= 1.36e-269) tmp = Float64(j * Float64(t * c)); elseif (y <= 9.2e-129) tmp = Float64(a * Float64(t * Float64(0.0 - x))); elseif (y <= 0.29) tmp = Float64(i * Float64(a * b)); else tmp = Float64(j * Float64(y * Float64(0.0 - i))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (y <= -9.5e-5) tmp = x * (y * z); elseif (y <= 1.36e-269) tmp = j * (t * c); elseif (y <= 9.2e-129) tmp = a * (t * (0.0 - x)); elseif (y <= 0.29) tmp = i * (a * b); else tmp = j * (y * (0.0 - i)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[y, -9.5e-5], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.36e-269], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 9.2e-129], N[(a * N[(t * N[(0.0 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 0.29], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], N[(j * N[(y * N[(0.0 - i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -9.5 \cdot 10^{-5}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;y \leq 1.36 \cdot 10^{-269}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{elif}\;y \leq 9.2 \cdot 10^{-129}:\\
\;\;\;\;a \cdot \left(t \cdot \left(0 - x\right)\right)\\
\mathbf{elif}\;y \leq 0.29:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;j \cdot \left(y \cdot \left(0 - i\right)\right)\\
\end{array}
\end{array}
if y < -9.5000000000000005e-5Initial program 69.9%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6444.8
Simplified44.8%
Taylor expanded in y around inf
*-lowering-*.f6438.4
Simplified38.4%
if -9.5000000000000005e-5 < y < 1.36e-269Initial program 78.3%
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--.f6436.4
Simplified36.4%
Taylor expanded in c around inf
*-lowering-*.f6433.1
Simplified33.1%
if 1.36e-269 < y < 9.1999999999999998e-129Initial program 88.1%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6449.5
Simplified49.5%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/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--.f6444.3
Simplified44.3%
if 9.1999999999999998e-129 < y < 0.28999999999999998Initial program 79.8%
Taylor expanded in a 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-*.f6455.4
Simplified55.4%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6441.5
Simplified41.5%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6447.0
Applied egg-rr47.0%
if 0.28999999999999998 < y Initial program 68.8%
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--.f6457.8
Simplified57.8%
Taylor expanded in c around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6447.9
Simplified47.9%
Final simplification41.3%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= i -1.9e+38)
(* i (fma j (- 0.0 y) (* a b)))
(if (<= i -2.7e-98)
(* x (- (* y z) (* t a)))
(if (<= i 3.8e-12)
(* c (fma j t (* z (- 0.0 b))))
(* i (- (* a b) (* y j)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (i <= -1.9e+38) {
tmp = i * fma(j, (0.0 - y), (a * b));
} else if (i <= -2.7e-98) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 3.8e-12) {
tmp = c * fma(j, t, (z * (0.0 - b)));
} else {
tmp = i * ((a * b) - (y * j));
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (i <= -1.9e+38) tmp = Float64(i * fma(j, Float64(0.0 - y), Float64(a * b))); elseif (i <= -2.7e-98) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (i <= 3.8e-12) tmp = Float64(c * fma(j, t, Float64(z * Float64(0.0 - b)))); else tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); end return tmp end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[i, -1.9e+38], N[(i * N[(j * N[(0.0 - y), $MachinePrecision] + N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, -2.7e-98], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.8e-12], N[(c * N[(j * t + N[(z * N[(0.0 - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;i \leq -1.9 \cdot 10^{+38}:\\
\;\;\;\;i \cdot \mathsf{fma}\left(j, 0 - y, a \cdot b\right)\\
\mathbf{elif}\;i \leq -2.7 \cdot 10^{-98}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;i \leq 3.8 \cdot 10^{-12}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(0 - b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\end{array}
\end{array}
if i < -1.8999999999999999e38Initial program 66.3%
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-*.f6466.8
Simplified66.8%
if -1.8999999999999999e38 < i < -2.6999999999999999e-98Initial program 70.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0
Simplified55.0%
if -2.6999999999999999e-98 < i < 3.79999999999999996e-12Initial program 83.5%
Taylor expanded in z around 0
Simplified81.5%
Taylor expanded in c around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6456.6
Simplified56.6%
if 3.79999999999999996e-12 < i Initial program 71.9%
Taylor expanded in z around 0
Simplified80.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified79.1%
Taylor expanded in i 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-*.f6467.4
Simplified67.4%
Final simplification61.6%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))))
(if (<= i -6.4e+32)
t_1
(if (<= i -1.85e-101)
(* x (- (* y z) (* t a)))
(if (<= i 8.6e-12) (* c (fma j t (* z (- 0.0 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 = i * ((a * b) - (y * j));
double tmp;
if (i <= -6.4e+32) {
tmp = t_1;
} else if (i <= -1.85e-101) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 8.6e-12) {
tmp = c * fma(j, t, (z * (0.0 - b)));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (i <= -6.4e+32) tmp = t_1; elseif (i <= -1.85e-101) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (i <= 8.6e-12) tmp = Float64(c * fma(j, t, Float64(z * Float64(0.0 - b)))); 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[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -6.4e+32], t$95$1, If[LessEqual[i, -1.85e-101], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 8.6e-12], N[(c * N[(j * t + N[(z * N[(0.0 - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -6.4 \cdot 10^{+32}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -1.85 \cdot 10^{-101}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;i \leq 8.6 \cdot 10^{-12}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(j, t, z \cdot \left(0 - b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -6.3999999999999998e32 or 8.59999999999999971e-12 < i Initial program 69.3%
Taylor expanded in z around 0
Simplified74.7%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified77.3%
Taylor expanded in i 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-*.f6466.3
Simplified66.3%
if -6.3999999999999998e32 < i < -1.85000000000000002e-101Initial program 70.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0
Simplified55.0%
if -1.85000000000000002e-101 < i < 8.59999999999999971e-12Initial program 83.5%
Taylor expanded in z around 0
Simplified81.5%
Taylor expanded in c around inf
*-lowering-*.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6456.6
Simplified56.6%
Final simplification61.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* i (- (* a b) (* y j)))))
(if (<= i -1.65e+35)
t_1
(if (<= i -1.15e-103)
(* x (- (* y z) (* t a)))
(if (<= i 3.7e-13) (* c (fma b (- 0.0 z) (* 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) - (y * j));
double tmp;
if (i <= -1.65e+35) {
tmp = t_1;
} else if (i <= -1.15e-103) {
tmp = x * ((y * z) - (t * a));
} else if (i <= 3.7e-13) {
tmp = c * fma(b, (0.0 - z), (t * j));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(i * Float64(Float64(a * b) - Float64(y * j))) tmp = 0.0 if (i <= -1.65e+35) tmp = t_1; elseif (i <= -1.15e-103) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); elseif (i <= 3.7e-13) tmp = Float64(c * fma(b, Float64(0.0 - z), Float64(t * j))); 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[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.65e+35], t$95$1, If[LessEqual[i, -1.15e-103], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 3.7e-13], N[(c * N[(b * N[(0.0 - z), $MachinePrecision] + N[(t * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{if}\;i \leq -1.65 \cdot 10^{+35}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -1.15 \cdot 10^{-103}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{elif}\;i \leq 3.7 \cdot 10^{-13}:\\
\;\;\;\;c \cdot \mathsf{fma}\left(b, 0 - z, t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.6500000000000001e35 or 3.69999999999999989e-13 < i Initial program 69.3%
Taylor expanded in z around 0
Simplified74.7%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified77.3%
Taylor expanded in i 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-*.f6466.3
Simplified66.3%
if -1.6500000000000001e35 < i < -1.15e-103Initial program 70.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6455.0
Simplified55.0%
if -1.15e-103 < i < 3.69999999999999989e-13Initial program 83.5%
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-*.f6455.6
Simplified55.6%
Final simplification60.8%
(FPCore (x y z t a b c i j)
:precision binary64
(if (<= b -6e+43)
(* i (* a b))
(if (<= b -1.35e-87)
(* x (* y z))
(if (<= b 1.95e-267)
(* a (* t (- 0.0 x)))
(if (<= b 125000.0) (* y (* x z)) (* a (* b i)))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -6e+43) {
tmp = i * (a * b);
} else if (b <= -1.35e-87) {
tmp = x * (y * z);
} else if (b <= 1.95e-267) {
tmp = a * (t * (0.0 - x));
} else if (b <= 125000.0) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-6d+43)) then
tmp = i * (a * b)
else if (b <= (-1.35d-87)) then
tmp = x * (y * z)
else if (b <= 1.95d-267) then
tmp = a * (t * (0.0d0 - x))
else if (b <= 125000.0d0) then
tmp = y * (x * z)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -6e+43) {
tmp = i * (a * b);
} else if (b <= -1.35e-87) {
tmp = x * (y * z);
} else if (b <= 1.95e-267) {
tmp = a * (t * (0.0 - x));
} else if (b <= 125000.0) {
tmp = y * (x * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -6e+43: tmp = i * (a * b) elif b <= -1.35e-87: tmp = x * (y * z) elif b <= 1.95e-267: tmp = a * (t * (0.0 - x)) elif b <= 125000.0: tmp = y * (x * z) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -6e+43) tmp = Float64(i * Float64(a * b)); elseif (b <= -1.35e-87) tmp = Float64(x * Float64(y * z)); elseif (b <= 1.95e-267) tmp = Float64(a * Float64(t * Float64(0.0 - x))); elseif (b <= 125000.0) tmp = Float64(y * Float64(x * z)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -6e+43) tmp = i * (a * b); elseif (b <= -1.35e-87) tmp = x * (y * z); elseif (b <= 1.95e-267) tmp = a * (t * (0.0 - x)); elseif (b <= 125000.0) tmp = y * (x * z); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -6e+43], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, -1.35e-87], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.95e-267], N[(a * N[(t * N[(0.0 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 125000.0], N[(y * N[(x * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -6 \cdot 10^{+43}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;b \leq -1.35 \cdot 10^{-87}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;b \leq 1.95 \cdot 10^{-267}:\\
\;\;\;\;a \cdot \left(t \cdot \left(0 - x\right)\right)\\
\mathbf{elif}\;b \leq 125000:\\
\;\;\;\;y \cdot \left(x \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if b < -6.00000000000000033e43Initial program 72.6%
Taylor expanded in a 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-*.f6448.3
Simplified48.3%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6453.9
Applied egg-rr53.9%
if -6.00000000000000033e43 < b < -1.34999999999999992e-87Initial program 81.5%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6448.1
Simplified48.1%
Taylor expanded in y around inf
*-lowering-*.f6438.4
Simplified38.4%
if -1.34999999999999992e-87 < b < 1.94999999999999988e-267Initial program 70.2%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6440.5
Simplified40.5%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/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--.f6434.5
Simplified34.5%
if 1.94999999999999988e-267 < b < 125000Initial program 76.7%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6445.4
Simplified45.4%
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
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6443.4
Simplified43.4%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f6436.8
Simplified36.8%
if 125000 < b Initial program 75.9%
Taylor expanded in a 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 t around 0
*-commutativeN/A
*-lowering-*.f6438.3
Simplified38.3%
Final simplification40.2%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* z (fma c (- 0.0 b) (* x y)))))
(if (<= z -6.8e+104)
t_1
(if (<= z 1.85e+21) (* i (- (* a b) (* y j))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = z * fma(c, (0.0 - b), (x * y));
double tmp;
if (z <= -6.8e+104) {
tmp = t_1;
} else if (z <= 1.85e+21) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(z * fma(c, Float64(0.0 - b), Float64(x * y))) tmp = 0.0 if (z <= -6.8e+104) tmp = t_1; elseif (z <= 1.85e+21) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); 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]}, If[LessEqual[z, -6.8e+104], t$95$1, If[LessEqual[z, 1.85e+21], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := z \cdot \mathsf{fma}\left(c, 0 - b, x \cdot y\right)\\
\mathbf{if}\;z \leq -6.8 \cdot 10^{+104}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.85 \cdot 10^{+21}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -6.7999999999999994e104 or 1.85e21 < z Initial program 73.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-*.f6464.2
Simplified64.2%
sub0-negN/A
neg-lowering-neg.f6464.2
Applied egg-rr64.2%
if -6.7999999999999994e104 < z < 1.85e21Initial program 75.8%
Taylor expanded in z around 0
Simplified75.4%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified56.7%
Taylor expanded in i 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-*.f6451.9
Simplified51.9%
Final simplification57.1%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* b (- (* a i) (* z c))))) (if (<= b -1.16e+20) t_1 (if (<= b 3.1e-6) (* x (- (* y z) (* t a))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -1.16e+20) {
tmp = t_1;
} else if (b <= 3.1e-6) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (b <= (-1.16d+20)) then
tmp = t_1
else if (b <= 3.1d-6) then
tmp = x * ((y * z) - (t * a))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (b <= -1.16e+20) {
tmp = t_1;
} else if (b <= 3.1e-6) {
tmp = x * ((y * z) - (t * a));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if b <= -1.16e+20: tmp = t_1 elif b <= 3.1e-6: tmp = x * ((y * z) - (t * a)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (b <= -1.16e+20) tmp = t_1; elseif (b <= 3.1e-6) tmp = Float64(x * Float64(Float64(y * z) - Float64(t * a))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (b <= -1.16e+20) tmp = t_1; elseif (b <= 3.1e-6) tmp = x * ((y * z) - (t * a)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -1.16e+20], t$95$1, If[LessEqual[b, 3.1e-6], N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;b \leq -1.16 \cdot 10^{+20}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;b \leq 3.1 \cdot 10^{-6}:\\
\;\;\;\;x \cdot \left(y \cdot z - t \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if b < -1.16e20 or 3.1e-6 < b Initial program 74.1%
Taylor expanded in z around 0
Simplified70.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified71.1%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6467.1
Simplified67.1%
if -1.16e20 < b < 3.1e-6Initial program 75.3%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6444.2
Simplified44.2%
Final simplification54.8%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* b (- (* a i) (* z c)))))
(if (<= z -8.2e+104)
t_1
(if (<= z 1.2e+22) (* i (- (* a b) (* y j))) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (z <= -8.2e+104) {
tmp = t_1;
} else if (z <= 1.2e+22) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = b * ((a * i) - (z * c))
if (z <= (-8.2d+104)) then
tmp = t_1
else if (z <= 1.2d+22) then
tmp = i * ((a * b) - (y * j))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = b * ((a * i) - (z * c));
double tmp;
if (z <= -8.2e+104) {
tmp = t_1;
} else if (z <= 1.2e+22) {
tmp = i * ((a * b) - (y * j));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = b * ((a * i) - (z * c)) tmp = 0 if z <= -8.2e+104: tmp = t_1 elif z <= 1.2e+22: tmp = i * ((a * b) - (y * j)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(b * Float64(Float64(a * i) - Float64(z * c))) tmp = 0.0 if (z <= -8.2e+104) tmp = t_1; elseif (z <= 1.2e+22) tmp = Float64(i * Float64(Float64(a * b) - Float64(y * j))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = b * ((a * i) - (z * c)); tmp = 0.0; if (z <= -8.2e+104) tmp = t_1; elseif (z <= 1.2e+22) tmp = i * ((a * b) - (y * j)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(b * N[(N[(a * i), $MachinePrecision] - N[(z * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.2e+104], t$95$1, If[LessEqual[z, 1.2e+22], N[(i * N[(N[(a * b), $MachinePrecision] - N[(y * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := b \cdot \left(a \cdot i - z \cdot c\right)\\
\mathbf{if}\;z \leq -8.2 \cdot 10^{+104}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.2 \cdot 10^{+22}:\\
\;\;\;\;i \cdot \left(a \cdot b - y \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -8.1999999999999997e104 or 1.2e22 < z Initial program 73.0%
Taylor expanded in z around 0
Simplified81.1%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified73.9%
Taylor expanded in y around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6449.0
Simplified49.0%
if -8.1999999999999997e104 < z < 1.2e22Initial program 76.0%
Taylor expanded in z around 0
Simplified75.6%
Taylor expanded in t around 0
associate-+r+N/A
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
mul-1-negN/A
associate-*r*N/A
distribute-rgt-inN/A
accelerator-lowering-fma.f64N/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
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
Simplified57.0%
Taylor expanded in i 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-*.f6451.6
Simplified51.6%
Final simplification50.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1 (* a (* b i))))
(if (<= i -1.65e+41)
t_1
(if (<= i -1.5e-135) (* x (* y z)) (if (<= i 9e-13) (* j (* t c)) t_1)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -1.65e+41) {
tmp = t_1;
} else if (i <= -1.5e-135) {
tmp = x * (y * z);
} else if (i <= 9e-13) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = a * (b * i)
if (i <= (-1.65d+41)) then
tmp = t_1
else if (i <= (-1.5d-135)) then
tmp = x * (y * z)
else if (i <= 9d-13) then
tmp = j * (t * c)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -1.65e+41) {
tmp = t_1;
} else if (i <= -1.5e-135) {
tmp = x * (y * z);
} else if (i <= 9e-13) {
tmp = j * (t * c);
} 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 i <= -1.65e+41: tmp = t_1 elif i <= -1.5e-135: tmp = x * (y * z) elif i <= 9e-13: tmp = j * (t * c) 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 (i <= -1.65e+41) tmp = t_1; elseif (i <= -1.5e-135) tmp = Float64(x * Float64(y * z)); elseif (i <= 9e-13) tmp = Float64(j * Float64(t * c)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); tmp = 0.0; if (i <= -1.65e+41) tmp = t_1; elseif (i <= -1.5e-135) tmp = x * (y * z); elseif (i <= 9e-13) tmp = j * (t * c); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -1.65e+41], t$95$1, If[LessEqual[i, -1.5e-135], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], If[LessEqual[i, 9e-13], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
\mathbf{if}\;i \leq -1.65 \cdot 10^{+41}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq -1.5 \cdot 10^{-135}:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{elif}\;i \leq 9 \cdot 10^{-13}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -1.65e41 or 9e-13 < i Initial program 68.8%
Taylor expanded in a 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.8
Simplified49.8%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6437.7
Simplified37.7%
if -1.65e41 < i < -1.50000000000000006e-135Initial program 75.7%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6449.5
Simplified49.5%
Taylor expanded in y around inf
*-lowering-*.f6435.4
Simplified35.4%
if -1.50000000000000006e-135 < i < 9e-13Initial program 82.4%
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--.f6439.3
Simplified39.3%
Taylor expanded in c around inf
*-lowering-*.f6433.0
Simplified33.0%
Final simplification35.6%
(FPCore (x y z t a b c i j) :precision binary64 (if (<= b -7.8e+43) (* i (* a b)) (if (<= b 180000.0) (* x (* y z)) (* a (* b i)))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -7.8e+43) {
tmp = i * (a * b);
} else if (b <= 180000.0) {
tmp = x * (y * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: tmp
if (b <= (-7.8d+43)) then
tmp = i * (a * b)
else if (b <= 180000.0d0) then
tmp = x * (y * z)
else
tmp = a * (b * i)
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double tmp;
if (b <= -7.8e+43) {
tmp = i * (a * b);
} else if (b <= 180000.0) {
tmp = x * (y * z);
} else {
tmp = a * (b * i);
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): tmp = 0 if b <= -7.8e+43: tmp = i * (a * b) elif b <= 180000.0: tmp = x * (y * z) else: tmp = a * (b * i) return tmp
function code(x, y, z, t, a, b, c, i, j) tmp = 0.0 if (b <= -7.8e+43) tmp = Float64(i * Float64(a * b)); elseif (b <= 180000.0) tmp = Float64(x * Float64(y * z)); else tmp = Float64(a * Float64(b * i)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) tmp = 0.0; if (b <= -7.8e+43) tmp = i * (a * b); elseif (b <= 180000.0) tmp = x * (y * z); else tmp = a * (b * i); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := If[LessEqual[b, -7.8e+43], N[(i * N[(a * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 180000.0], N[(x * N[(y * z), $MachinePrecision]), $MachinePrecision], N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -7.8 \cdot 10^{+43}:\\
\;\;\;\;i \cdot \left(a \cdot b\right)\\
\mathbf{elif}\;b \leq 180000:\\
\;\;\;\;x \cdot \left(y \cdot z\right)\\
\mathbf{else}:\\
\;\;\;\;a \cdot \left(b \cdot i\right)\\
\end{array}
\end{array}
if b < -7.8000000000000001e43Initial program 72.6%
Taylor expanded in a 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-*.f6448.3
Simplified48.3%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6442.7
Simplified42.7%
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f6453.9
Applied egg-rr53.9%
if -7.8000000000000001e43 < b < 1.8e5Initial program 75.0%
Taylor expanded in x around inf
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6443.8
Simplified43.8%
Taylor expanded in y around inf
*-lowering-*.f6427.2
Simplified27.2%
if 1.8e5 < b Initial program 75.9%
Taylor expanded in a 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 t around 0
*-commutativeN/A
*-lowering-*.f6438.3
Simplified38.3%
Final simplification35.2%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* a (* b i)))) (if (<= i -0.0078) t_1 (if (<= i 8.5e-12) (* j (* t c)) t_1))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -0.0078) {
tmp = t_1;
} else if (i <= 8.5e-12) {
tmp = j * (t * c);
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: tmp
t_1 = a * (b * i)
if (i <= (-0.0078d0)) then
tmp = t_1
else if (i <= 8.5d-12) then
tmp = j * (t * c)
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = a * (b * i);
double tmp;
if (i <= -0.0078) {
tmp = t_1;
} else if (i <= 8.5e-12) {
tmp = j * (t * c);
} 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 i <= -0.0078: tmp = t_1 elif i <= 8.5e-12: tmp = j * (t * c) 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 (i <= -0.0078) tmp = t_1; elseif (i <= 8.5e-12) tmp = Float64(j * Float64(t * c)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = a * (b * i); tmp = 0.0; if (i <= -0.0078) tmp = t_1; elseif (i <= 8.5e-12) tmp = j * (t * c); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(a * N[(b * i), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[i, -0.0078], t$95$1, If[LessEqual[i, 8.5e-12], N[(j * N[(t * c), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := a \cdot \left(b \cdot i\right)\\
\mathbf{if}\;i \leq -0.0078:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 8.5 \cdot 10^{-12}:\\
\;\;\;\;j \cdot \left(t \cdot c\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -0.0077999999999999996 or 8.4999999999999997e-12 < i Initial program 69.6%
Taylor expanded in a 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-*.f6447.6
Simplified47.6%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6435.2
Simplified35.2%
if -0.0077999999999999996 < i < 8.4999999999999997e-12Initial program 80.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--.f6438.8
Simplified38.8%
Taylor expanded in c around inf
*-lowering-*.f6429.9
Simplified29.9%
Final simplification32.7%
(FPCore (x y z t a b c i j) :precision binary64 (let* ((t_1 (* a (* b i)))) (if (<= i -2.1e+23) t_1 (if (<= i 4.4e-13) (* 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 (i <= -2.1e+23) {
tmp = t_1;
} else if (i <= 4.4e-13) {
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 (i <= (-2.1d+23)) then
tmp = t_1
else if (i <= 4.4d-13) 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 (i <= -2.1e+23) {
tmp = t_1;
} else if (i <= 4.4e-13) {
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 i <= -2.1e+23: tmp = t_1 elif i <= 4.4e-13: 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 (i <= -2.1e+23) tmp = t_1; elseif (i <= 4.4e-13) 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 (i <= -2.1e+23) tmp = t_1; elseif (i <= 4.4e-13) 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[i, -2.1e+23], t$95$1, If[LessEqual[i, 4.4e-13], 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}\;i \leq -2.1 \cdot 10^{+23}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;i \leq 4.4 \cdot 10^{-13}:\\
\;\;\;\;c \cdot \left(t \cdot j\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if i < -2.1000000000000001e23 or 4.39999999999999993e-13 < i Initial program 69.4%
Taylor expanded in a 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.1
Simplified49.1%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6436.8
Simplified36.8%
if -2.1000000000000001e23 < i < 4.39999999999999993e-13Initial program 80.2%
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--.f6436.9
Simplified36.9%
Taylor expanded in c around inf
*-lowering-*.f64N/A
*-lowering-*.f6428.4
Simplified28.4%
Final simplification32.7%
(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 74.7%
Taylor expanded in a 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-*.f6437.8
Simplified37.8%
Taylor expanded in t around 0
*-commutativeN/A
*-lowering-*.f6422.5
Simplified22.5%
Final simplification22.5%
(FPCore (x y z t a b c i j)
:precision binary64
(let* ((t_1
(+
(- (* x (- (* y z) (* t a))) (* b (- (* c z) (* i a))))
(/
(* j (- (pow (* c t) 2.0) (pow (* i y) 2.0)))
(+ (* c t) (* i y)))))
(t_2
(-
(* x (- (* z y) (* a t)))
(- (* b (- (* z c) (* a i))) (* (- (* c t) (* y i)) j)))))
(if (< t -8.120978919195912e-33)
t_2
(if (< t -4.712553818218485e-169)
t_1
(if (< t -7.633533346031584e-308)
t_2
(if (< t 1.0535888557455487e-139) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (pow((c * t), 2.0) - pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b, c, i, j)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: i
real(8), intent (in) :: j
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ** 2.0d0) - ((i * y) ** 2.0d0))) / ((c * t) + (i * y)))
t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j))
if (t < (-8.120978919195912d-33)) then
tmp = t_2
else if (t < (-4.712553818218485d-169)) then
tmp = t_1
else if (t < (-7.633533346031584d-308)) then
tmp = t_2
else if (t < 1.0535888557455487d-139) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b, double c, double i, double j) {
double t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (Math.pow((c * t), 2.0) - Math.pow((i * y), 2.0))) / ((c * t) + (i * y)));
double t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j));
double tmp;
if (t < -8.120978919195912e-33) {
tmp = t_2;
} else if (t < -4.712553818218485e-169) {
tmp = t_1;
} else if (t < -7.633533346031584e-308) {
tmp = t_2;
} else if (t < 1.0535888557455487e-139) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b, c, i, j): t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (math.pow((c * t), 2.0) - math.pow((i * y), 2.0))) / ((c * t) + (i * y))) t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)) tmp = 0 if t < -8.120978919195912e-33: tmp = t_2 elif t < -4.712553818218485e-169: tmp = t_1 elif t < -7.633533346031584e-308: tmp = t_2 elif t < 1.0535888557455487e-139: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b, c, i, j) t_1 = Float64(Float64(Float64(x * Float64(Float64(y * z) - Float64(t * a))) - Float64(b * Float64(Float64(c * z) - Float64(i * a)))) + Float64(Float64(j * Float64((Float64(c * t) ^ 2.0) - (Float64(i * y) ^ 2.0))) / Float64(Float64(c * t) + Float64(i * y)))) t_2 = Float64(Float64(x * Float64(Float64(z * y) - Float64(a * t))) - Float64(Float64(b * Float64(Float64(z * c) - Float64(a * i))) - Float64(Float64(Float64(c * t) - Float64(y * i)) * j))) tmp = 0.0 if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b, c, i, j) t_1 = ((x * ((y * z) - (t * a))) - (b * ((c * z) - (i * a)))) + ((j * (((c * t) ^ 2.0) - ((i * y) ^ 2.0))) / ((c * t) + (i * y))); t_2 = (x * ((z * y) - (a * t))) - ((b * ((z * c) - (a * i))) - (((c * t) - (y * i)) * j)); tmp = 0.0; if (t < -8.120978919195912e-33) tmp = t_2; elseif (t < -4.712553818218485e-169) tmp = t_1; elseif (t < -7.633533346031584e-308) tmp = t_2; elseif (t < 1.0535888557455487e-139) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_, c_, i_, j_] := Block[{t$95$1 = N[(N[(N[(x * N[(N[(y * z), $MachinePrecision] - N[(t * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(b * N[(N[(c * z), $MachinePrecision] - N[(i * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(j * N[(N[Power[N[(c * t), $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[(i * y), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(c * t), $MachinePrecision] + N[(i * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(N[(z * y), $MachinePrecision] - N[(a * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(b * N[(N[(z * c), $MachinePrecision] - N[(a * i), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(N[(c * t), $MachinePrecision] - N[(y * i), $MachinePrecision]), $MachinePrecision] * j), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -8.120978919195912e-33], t$95$2, If[Less[t, -4.712553818218485e-169], t$95$1, If[Less[t, -7.633533346031584e-308], t$95$2, If[Less[t, 1.0535888557455487e-139], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(x \cdot \left(y \cdot z - t \cdot a\right) - b \cdot \left(c \cdot z - i \cdot a\right)\right) + \frac{j \cdot \left({\left(c \cdot t\right)}^{2} - {\left(i \cdot y\right)}^{2}\right)}{c \cdot t + i \cdot y}\\
t_2 := x \cdot \left(z \cdot y - a \cdot t\right) - \left(b \cdot \left(z \cdot c - a \cdot i\right) - \left(c \cdot t - y \cdot i\right) \cdot j\right)\\
\mathbf{if}\;t < -8.120978919195912 \cdot 10^{-33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < -4.712553818218485 \cdot 10^{-169}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t < -7.633533346031584 \cdot 10^{-308}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 1.0535888557455487 \cdot 10^{-139}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024196
(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)))))