
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
code = ((x_46im * y_46re) - (x_46re * y_46im)) / ((y_46re * y_46re) + (y_46im * y_46im))
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im))
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(Float64(Float64(x_46_im * y_46_re) - Float64(x_46_re * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)); end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(N[(x$46$im * y$46$re), $MachinePrecision] - N[(x$46$re * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
code = ((x_46im * y_46re) - (x_46re * y_46im)) / ((y_46re * y_46re) + (y_46im * y_46im))
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im))
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(Float64(Float64(x_46_im * y_46_re) - Float64(x_46_re * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)); end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(N[(x$46$im * y$46$re), $MachinePrecision] - N[(x$46$re * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}
\end{array}
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (fma y.im y.im (* y.re y.re)))
(t_1 (fma y.im (/ (- 0.0 x.re) t_0) (fma y.re (/ x.im t_0) 0.0))))
(if (<= y.im -5.8e+140)
(/ -1.0 (/ y.im x.re))
(if (<= y.im -8e-146)
t_1
(if (<= y.im 2.4e-52)
(/ (- x.im (* x.re (/ y.im y.re))) y.re)
(if (<= y.im 8.4e+124)
t_1
(/ (fma y.re (/ x.im y.im) (- 0.0 x.re)) y.im)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = fma(y_46_im, y_46_im, (y_46_re * y_46_re));
double t_1 = fma(y_46_im, ((0.0 - x_46_re) / t_0), fma(y_46_re, (x_46_im / t_0), 0.0));
double tmp;
if (y_46_im <= -5.8e+140) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -8e-146) {
tmp = t_1;
} else if (y_46_im <= 2.4e-52) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else if (y_46_im <= 8.4e+124) {
tmp = t_1;
} else {
tmp = fma(y_46_re, (x_46_im / y_46_im), (0.0 - x_46_re)) / y_46_im;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = fma(y_46_im, y_46_im, Float64(y_46_re * y_46_re)) t_1 = fma(y_46_im, Float64(Float64(0.0 - x_46_re) / t_0), fma(y_46_re, Float64(x_46_im / t_0), 0.0)) tmp = 0.0 if (y_46_im <= -5.8e+140) tmp = Float64(-1.0 / Float64(y_46_im / x_46_re)); elseif (y_46_im <= -8e-146) tmp = t_1; elseif (y_46_im <= 2.4e-52) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); elseif (y_46_im <= 8.4e+124) tmp = t_1; else tmp = Float64(fma(y_46_re, Float64(x_46_im / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * y$46$im + N[(y$46$re * y$46$re), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$im * N[(N[(0.0 - x$46$re), $MachinePrecision] / t$95$0), $MachinePrecision] + N[(y$46$re * N[(x$46$im / t$95$0), $MachinePrecision] + 0.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$im, -5.8e+140], N[(-1.0 / N[(y$46$im / x$46$re), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, -8e-146], t$95$1, If[LessEqual[y$46$im, 2.4e-52], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], If[LessEqual[y$46$im, 8.4e+124], t$95$1, N[(N[(y$46$re * N[(x$46$im / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(y.im, y.im, y.re \cdot y.re\right)\\
t_1 := \mathsf{fma}\left(y.im, \frac{0 - x.re}{t\_0}, \mathsf{fma}\left(y.re, \frac{x.im}{t\_0}, 0\right)\right)\\
\mathbf{if}\;y.im \leq -5.8 \cdot 10^{+140}:\\
\;\;\;\;\frac{-1}{\frac{y.im}{x.re}}\\
\mathbf{elif}\;y.im \leq -8 \cdot 10^{-146}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y.im \leq 2.4 \cdot 10^{-52}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{elif}\;y.im \leq 8.4 \cdot 10^{+124}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y.re, \frac{x.im}{y.im}, 0 - x.re\right)}{y.im}\\
\end{array}
\end{array}
if y.im < -5.7999999999999998e140Initial program 38.1%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6489.1
Simplified89.1%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6489.3
Simplified89.3%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr90.7%
if -5.7999999999999998e140 < y.im < -8.00000000000000021e-146 or 2.4000000000000002e-52 < y.im < 8.40000000000000046e124Initial program 72.0%
Taylor expanded in x.im around 0
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
unpow2N/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-rgt-identityN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified83.9%
if -8.00000000000000021e-146 < y.im < 2.4000000000000002e-52Initial program 63.0%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6463.0
Applied egg-rr63.0%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6490.6
Simplified90.6%
if 8.40000000000000046e124 < y.im Initial program 26.8%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6491.4
Simplified91.4%
sub0-negN/A
neg-lowering-neg.f6491.4
Applied egg-rr91.4%
Final simplification88.2%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (fma y.re y.re (* y.im y.im))))
(if (<= y.im -1.4e+115)
(/ (fma x.im (/ y.re y.im) (- 0.0 x.re)) y.im)
(if (<= y.im -1.15e-94)
(fma y.im (/ (- 0.0 x.re) t_0) (/ (* y.re x.im) t_0))
(if (<= y.im 1.4e-14)
(/ (- x.im (* x.re (/ y.im y.re))) y.re)
(/ (fma y.re (/ x.im y.im) (- 0.0 x.re)) y.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = fma(y_46_re, y_46_re, (y_46_im * y_46_im));
double tmp;
if (y_46_im <= -1.4e+115) {
tmp = fma(x_46_im, (y_46_re / y_46_im), (0.0 - x_46_re)) / y_46_im;
} else if (y_46_im <= -1.15e-94) {
tmp = fma(y_46_im, ((0.0 - x_46_re) / t_0), ((y_46_re * x_46_im) / t_0));
} else if (y_46_im <= 1.4e-14) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = fma(y_46_re, (x_46_im / y_46_im), (0.0 - x_46_re)) / y_46_im;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = fma(y_46_re, y_46_re, Float64(y_46_im * y_46_im)) tmp = 0.0 if (y_46_im <= -1.4e+115) tmp = Float64(fma(x_46_im, Float64(y_46_re / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); elseif (y_46_im <= -1.15e-94) tmp = fma(y_46_im, Float64(Float64(0.0 - x_46_re) / t_0), Float64(Float64(y_46_re * x_46_im) / t_0)); elseif (y_46_im <= 1.4e-14) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = Float64(fma(y_46_re, Float64(x_46_im / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$re * y$46$re + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$im, -1.4e+115], N[(N[(x$46$im * N[(y$46$re / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$im, -1.15e-94], N[(y$46$im * N[(N[(0.0 - x$46$re), $MachinePrecision] / t$95$0), $MachinePrecision] + N[(N[(y$46$re * x$46$im), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(N[(y$46$re * N[(x$46$im / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)\\
\mathbf{if}\;y.im \leq -1.4 \cdot 10^{+115}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x.im, \frac{y.re}{y.im}, 0 - x.re\right)}{y.im}\\
\mathbf{elif}\;y.im \leq -1.15 \cdot 10^{-94}:\\
\;\;\;\;\mathsf{fma}\left(y.im, \frac{0 - x.re}{t\_0}, \frac{y.re \cdot x.im}{t\_0}\right)\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y.re, \frac{x.im}{y.im}, 0 - x.re\right)}{y.im}\\
\end{array}
\end{array}
if y.im < -1.4e115Initial program 35.8%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6487.9
Simplified87.9%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.9
Applied egg-rr87.9%
flip3--N/A
div-invN/A
metadata-evalN/A
sub0-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
sub0-negN/A
sub0-negN/A
pow-prod-downN/A
sqr-powN/A
sub0-negN/A
cube-negN/A
sub0-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
div-invN/A
flip3--N/A
neg-lowering-neg.f64N/A
Applied egg-rr87.9%
if -1.4e115 < y.im < -1.15e-94Initial program 81.5%
div-subN/A
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
accelerator-lowering-fma.f64N/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6483.7
Applied egg-rr83.7%
if -1.15e-94 < y.im < 1.4e-14Initial program 62.6%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6462.6
Applied egg-rr62.6%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.0
Simplified86.0%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
sub0-negN/A
neg-lowering-neg.f6484.6
Applied egg-rr84.6%
Final simplification85.5%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -5.5e+115)
(/ (fma x.im (/ y.re y.im) (- 0.0 x.re)) y.im)
(if (<= y.im -1.15e-94)
(/ (- (* y.re x.im) (* y.im x.re)) (fma y.re y.re (* y.im y.im)))
(if (<= y.im 1.4e-14)
(/ (- x.im (* x.re (/ y.im y.re))) y.re)
(/ (fma y.re (/ x.im y.im) (- 0.0 x.re)) y.im)))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -5.5e+115) {
tmp = fma(x_46_im, (y_46_re / y_46_im), (0.0 - x_46_re)) / y_46_im;
} else if (y_46_im <= -1.15e-94) {
tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / fma(y_46_re, y_46_re, (y_46_im * y_46_im));
} else if (y_46_im <= 1.4e-14) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = fma(y_46_re, (x_46_im / y_46_im), (0.0 - x_46_re)) / y_46_im;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -5.5e+115) tmp = Float64(fma(x_46_im, Float64(y_46_re / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); elseif (y_46_im <= -1.15e-94) tmp = Float64(Float64(Float64(y_46_re * x_46_im) - Float64(y_46_im * x_46_re)) / fma(y_46_re, y_46_re, Float64(y_46_im * y_46_im))); elseif (y_46_im <= 1.4e-14) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = Float64(fma(y_46_re, Float64(x_46_im / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -5.5e+115], N[(N[(x$46$im * N[(y$46$re / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$im, -1.15e-94], N[(N[(N[(y$46$re * x$46$im), $MachinePrecision] - N[(y$46$im * x$46$re), $MachinePrecision]), $MachinePrecision] / N[(y$46$re * y$46$re + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(N[(y$46$re * N[(x$46$im / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -5.5 \cdot 10^{+115}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x.im, \frac{y.re}{y.im}, 0 - x.re\right)}{y.im}\\
\mathbf{elif}\;y.im \leq -1.15 \cdot 10^{-94}:\\
\;\;\;\;\frac{y.re \cdot x.im - y.im \cdot x.re}{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y.re, \frac{x.im}{y.im}, 0 - x.re\right)}{y.im}\\
\end{array}
\end{array}
if y.im < -5.5e115Initial program 35.8%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6487.9
Simplified87.9%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6487.9
Applied egg-rr87.9%
flip3--N/A
div-invN/A
metadata-evalN/A
sub0-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
sub0-negN/A
sub0-negN/A
pow-prod-downN/A
sqr-powN/A
sub0-negN/A
cube-negN/A
sub0-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
div-invN/A
flip3--N/A
neg-lowering-neg.f64N/A
Applied egg-rr87.9%
if -5.5e115 < y.im < -1.15e-94Initial program 81.5%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6481.5
Applied egg-rr81.5%
if -1.15e-94 < y.im < 1.4e-14Initial program 62.6%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6462.6
Applied egg-rr62.6%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.0
Simplified86.0%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
sub0-negN/A
neg-lowering-neg.f6484.6
Applied egg-rr84.6%
Final simplification85.1%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -3.6e+96)
(/ -1.0 (/ y.im x.re))
(if (<= y.im -75000000000.0)
(/ (- (* y.re x.im) (* y.im x.re)) (* y.im y.im))
(if (<= y.im 1.4e-14)
(/ (- x.im (* x.re (/ y.im y.re))) y.re)
(- 0.0 (/ x.re y.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -3.6e+96) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -75000000000.0) {
tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im);
} else if (y_46_im <= 1.4e-14) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (y_46im <= (-3.6d+96)) then
tmp = (-1.0d0) / (y_46im / x_46re)
else if (y_46im <= (-75000000000.0d0)) then
tmp = ((y_46re * x_46im) - (y_46im * x_46re)) / (y_46im * y_46im)
else if (y_46im <= 1.4d-14) then
tmp = (x_46im - (x_46re * (y_46im / y_46re))) / y_46re
else
tmp = 0.0d0 - (x_46re / y_46im)
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -3.6e+96) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -75000000000.0) {
tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im);
} else if (y_46_im <= 1.4e-14) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if y_46_im <= -3.6e+96: tmp = -1.0 / (y_46_im / x_46_re) elif y_46_im <= -75000000000.0: tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im) elif y_46_im <= 1.4e-14: tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re else: tmp = 0.0 - (x_46_re / y_46_im) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -3.6e+96) tmp = Float64(-1.0 / Float64(y_46_im / x_46_re)); elseif (y_46_im <= -75000000000.0) tmp = Float64(Float64(Float64(y_46_re * x_46_im) - Float64(y_46_im * x_46_re)) / Float64(y_46_im * y_46_im)); elseif (y_46_im <= 1.4e-14) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = Float64(0.0 - Float64(x_46_re / y_46_im)); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (y_46_im <= -3.6e+96) tmp = -1.0 / (y_46_im / x_46_re); elseif (y_46_im <= -75000000000.0) tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im); elseif (y_46_im <= 1.4e-14) tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re; else tmp = 0.0 - (x_46_re / y_46_im); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -3.6e+96], N[(-1.0 / N[(y$46$im / x$46$re), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, -75000000000.0], N[(N[(N[(y$46$re * x$46$im), $MachinePrecision] - N[(y$46$im * x$46$re), $MachinePrecision]), $MachinePrecision] / N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(0.0 - N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -3.6 \cdot 10^{+96}:\\
\;\;\;\;\frac{-1}{\frac{y.im}{x.re}}\\
\mathbf{elif}\;y.im \leq -75000000000:\\
\;\;\;\;\frac{y.re \cdot x.im - y.im \cdot x.re}{y.im \cdot y.im}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x.re}{y.im}\\
\end{array}
\end{array}
if y.im < -3.60000000000000013e96Initial program 40.1%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.2
Simplified84.2%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6479.6
Simplified79.6%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr80.6%
if -3.60000000000000013e96 < y.im < -7.5e10Initial program 82.1%
Taylor expanded in y.re around 0
unpow2N/A
*-lowering-*.f6466.2
Simplified66.2%
if -7.5e10 < y.im < 1.4e-14Initial program 66.0%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6466.0
Applied egg-rr66.0%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6481.6
Simplified81.6%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6472.3
Simplified72.3%
+-lft-identityN/A
sub0-negN/A
neg-lowering-neg.f64N/A
+-lft-identity72.3
Applied egg-rr72.3%
Final simplification77.8%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -2.5e+15)
(/ (fma x.im (/ y.re y.im) (- 0.0 x.re)) y.im)
(if (<= y.im 1.4e-14)
(/ (- x.im (* x.re (/ y.im y.re))) y.re)
(/ (fma y.re (/ x.im y.im) (- 0.0 x.re)) y.im))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2.5e+15) {
tmp = fma(x_46_im, (y_46_re / y_46_im), (0.0 - x_46_re)) / y_46_im;
} else if (y_46_im <= 1.4e-14) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = fma(y_46_re, (x_46_im / y_46_im), (0.0 - x_46_re)) / y_46_im;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -2.5e+15) tmp = Float64(fma(x_46_im, Float64(y_46_re / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); elseif (y_46_im <= 1.4e-14) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = Float64(fma(y_46_re, Float64(x_46_im / y_46_im), Float64(0.0 - x_46_re)) / y_46_im); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -2.5e+15], N[(N[(x$46$im * N[(y$46$re / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(N[(y$46$re * N[(x$46$im / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -2.5 \cdot 10^{+15}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x.im, \frac{y.re}{y.im}, 0 - x.re\right)}{y.im}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(y.re, \frac{x.im}{y.im}, 0 - x.re\right)}{y.im}\\
\end{array}
\end{array}
if y.im < -2.5e15Initial program 52.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6480.6
Simplified80.6%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6480.6
Applied egg-rr80.6%
flip3--N/A
div-invN/A
metadata-evalN/A
sub0-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
sub0-negN/A
sub0-negN/A
pow-prod-downN/A
sqr-powN/A
sub0-negN/A
cube-negN/A
sub0-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
div-invN/A
flip3--N/A
neg-lowering-neg.f64N/A
Applied egg-rr80.6%
if -2.5e15 < y.im < 1.4e-14Initial program 66.0%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6466.0
Applied egg-rr66.0%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6481.6
Simplified81.6%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
sub0-negN/A
neg-lowering-neg.f6484.6
Applied egg-rr84.6%
Final simplification82.2%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0 (/ (fma x.im (/ y.re y.im) (- 0.0 x.re)) y.im)))
(if (<= y.im -2.5e+15)
t_0
(if (<= y.im 1.1e-15) (/ (- x.im (* x.re (/ y.im y.re))) y.re) t_0))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = fma(x_46_im, (y_46_re / y_46_im), (0.0 - x_46_re)) / y_46_im;
double tmp;
if (y_46_im <= -2.5e+15) {
tmp = t_0;
} else if (y_46_im <= 1.1e-15) {
tmp = (x_46_im - (x_46_re * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = t_0;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(fma(x_46_im, Float64(y_46_re / y_46_im), Float64(0.0 - x_46_re)) / y_46_im) tmp = 0.0 if (y_46_im <= -2.5e+15) tmp = t_0; elseif (y_46_im <= 1.1e-15) tmp = Float64(Float64(x_46_im - Float64(x_46_re * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = t_0; end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[(x$46$im * N[(y$46$re / y$46$im), $MachinePrecision] + N[(0.0 - x$46$re), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]}, If[LessEqual[y$46$im, -2.5e+15], t$95$0, If[LessEqual[y$46$im, 1.1e-15], N[(N[(x$46$im - N[(x$46$re * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\mathsf{fma}\left(x.im, \frac{y.re}{y.im}, 0 - x.re\right)}{y.im}\\
\mathbf{if}\;y.im \leq -2.5 \cdot 10^{+15}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.im \leq 1.1 \cdot 10^{-15}:\\
\;\;\;\;\frac{x.im - x.re \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y.im < -2.5e15 or 1.09999999999999993e-15 < y.im Initial program 48.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6482.9
Simplified82.9%
associate-*r/N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
--lowering--.f6481.7
Applied egg-rr81.7%
flip3--N/A
div-invN/A
metadata-evalN/A
sub0-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
sub0-negN/A
sub0-negN/A
pow-prod-downN/A
sqr-powN/A
sub0-negN/A
cube-negN/A
sub0-negN/A
metadata-evalN/A
distribute-lft-neg-inN/A
div-invN/A
flip3--N/A
neg-lowering-neg.f64N/A
Applied egg-rr81.7%
if -2.5e15 < y.im < 1.09999999999999993e-15Initial program 66.0%
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f6466.0
Applied egg-rr66.0%
Taylor expanded in y.re around inf
/-lowering-/.f64N/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f6481.6
Simplified81.6%
Final simplification81.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -2.5e+89)
(/ -1.0 (/ y.im x.re))
(if (<= y.im -2e-83)
(* x.re (/ (- 0.0 y.im) (fma y.re y.re (* y.im y.im))))
(if (<= y.im 1.4e-14) (/ x.im y.re) (- 0.0 (/ x.re y.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2.5e+89) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -2e-83) {
tmp = x_46_re * ((0.0 - y_46_im) / fma(y_46_re, y_46_re, (y_46_im * y_46_im)));
} else if (y_46_im <= 1.4e-14) {
tmp = x_46_im / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -2.5e+89) tmp = Float64(-1.0 / Float64(y_46_im / x_46_re)); elseif (y_46_im <= -2e-83) tmp = Float64(x_46_re * Float64(Float64(0.0 - y_46_im) / fma(y_46_re, y_46_re, Float64(y_46_im * y_46_im)))); elseif (y_46_im <= 1.4e-14) tmp = Float64(x_46_im / y_46_re); else tmp = Float64(0.0 - Float64(x_46_re / y_46_im)); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -2.5e+89], N[(-1.0 / N[(y$46$im / x$46$re), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, -2e-83], N[(x$46$re * N[(N[(0.0 - y$46$im), $MachinePrecision] / N[(y$46$re * y$46$re + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(x$46$im / y$46$re), $MachinePrecision], N[(0.0 - N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -2.5 \cdot 10^{+89}:\\
\;\;\;\;\frac{-1}{\frac{y.im}{x.re}}\\
\mathbf{elif}\;y.im \leq -2 \cdot 10^{-83}:\\
\;\;\;\;x.re \cdot \frac{0 - y.im}{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im}{y.re}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x.re}{y.im}\\
\end{array}
\end{array}
if y.im < -2.49999999999999992e89Initial program 41.6%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6480.1
Simplified80.1%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr81.1%
if -2.49999999999999992e89 < y.im < -2.0000000000000001e-83Initial program 81.5%
Taylor expanded in x.im around 0
mul-1-negN/A
distribute-neg-frac2N/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
neg-sub0N/A
--lowering--.f64N/A
unpow2N/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-rgt-identityN/A
*-commutativeN/A
associate-/l*N/A
accelerator-lowering-fma.f64N/A
Simplified84.5%
Taylor expanded in x.re around inf
mul-1-negN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
mul-1-negN/A
*-lowering-*.f64N/A
mul-1-negN/A
distribute-neg-frac2N/A
distribute-neg-outN/A
mul-1-negN/A
sub-negN/A
/-lowering-/.f64N/A
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
neg-sub0N/A
--lowering--.f64N/A
+-commutativeN/A
unpow2N/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6457.0
Simplified57.0%
if -2.0000000000000001e-83 < y.im < 1.4e-14Initial program 62.6%
Taylor expanded in y.re around inf
/-lowering-/.f6470.5
Simplified70.5%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6472.3
Simplified72.3%
+-lft-identityN/A
sub0-negN/A
neg-lowering-neg.f64N/A
+-lft-identity72.3
Applied egg-rr72.3%
Final simplification70.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -2.6e+89)
(/ -1.0 (/ y.im x.re))
(if (<= y.im -2e-83)
(/ (- (* y.re x.im) (* y.im x.re)) (* y.im y.im))
(if (<= y.im 1.4e-14) (/ x.im y.re) (- 0.0 (/ x.re y.im))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2.6e+89) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -2e-83) {
tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im);
} else if (y_46_im <= 1.4e-14) {
tmp = x_46_im / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (y_46im <= (-2.6d+89)) then
tmp = (-1.0d0) / (y_46im / x_46re)
else if (y_46im <= (-2d-83)) then
tmp = ((y_46re * x_46im) - (y_46im * x_46re)) / (y_46im * y_46im)
else if (y_46im <= 1.4d-14) then
tmp = x_46im / y_46re
else
tmp = 0.0d0 - (x_46re / y_46im)
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2.6e+89) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= -2e-83) {
tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im);
} else if (y_46_im <= 1.4e-14) {
tmp = x_46_im / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if y_46_im <= -2.6e+89: tmp = -1.0 / (y_46_im / x_46_re) elif y_46_im <= -2e-83: tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im) elif y_46_im <= 1.4e-14: tmp = x_46_im / y_46_re else: tmp = 0.0 - (x_46_re / y_46_im) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -2.6e+89) tmp = Float64(-1.0 / Float64(y_46_im / x_46_re)); elseif (y_46_im <= -2e-83) tmp = Float64(Float64(Float64(y_46_re * x_46_im) - Float64(y_46_im * x_46_re)) / Float64(y_46_im * y_46_im)); elseif (y_46_im <= 1.4e-14) tmp = Float64(x_46_im / y_46_re); else tmp = Float64(0.0 - Float64(x_46_re / y_46_im)); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (y_46_im <= -2.6e+89) tmp = -1.0 / (y_46_im / x_46_re); elseif (y_46_im <= -2e-83) tmp = ((y_46_re * x_46_im) - (y_46_im * x_46_re)) / (y_46_im * y_46_im); elseif (y_46_im <= 1.4e-14) tmp = x_46_im / y_46_re; else tmp = 0.0 - (x_46_re / y_46_im); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -2.6e+89], N[(-1.0 / N[(y$46$im / x$46$re), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, -2e-83], N[(N[(N[(y$46$re * x$46$im), $MachinePrecision] - N[(y$46$im * x$46$re), $MachinePrecision]), $MachinePrecision] / N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(x$46$im / y$46$re), $MachinePrecision], N[(0.0 - N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -2.6 \cdot 10^{+89}:\\
\;\;\;\;\frac{-1}{\frac{y.im}{x.re}}\\
\mathbf{elif}\;y.im \leq -2 \cdot 10^{-83}:\\
\;\;\;\;\frac{y.re \cdot x.im - y.im \cdot x.re}{y.im \cdot y.im}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im}{y.re}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x.re}{y.im}\\
\end{array}
\end{array}
if y.im < -2.6000000000000001e89Initial program 40.1%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.2
Simplified84.2%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6479.6
Simplified79.6%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr80.6%
if -2.6000000000000001e89 < y.im < -2.0000000000000001e-83Initial program 82.0%
Taylor expanded in y.re around 0
unpow2N/A
*-lowering-*.f6455.5
Simplified55.5%
if -2.0000000000000001e-83 < y.im < 1.4e-14Initial program 62.6%
Taylor expanded in y.re around inf
/-lowering-/.f6470.5
Simplified70.5%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6472.3
Simplified72.3%
+-lft-identityN/A
sub0-negN/A
neg-lowering-neg.f64N/A
+-lft-identity72.3
Applied egg-rr72.3%
Final simplification70.3%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (<= y.im -2e-83) (/ -1.0 (/ y.im x.re)) (if (<= y.im 1.4e-14) (/ x.im y.re) (- 0.0 (/ x.re y.im)))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2e-83) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= 1.4e-14) {
tmp = x_46_im / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (y_46im <= (-2d-83)) then
tmp = (-1.0d0) / (y_46im / x_46re)
else if (y_46im <= 1.4d-14) then
tmp = x_46im / y_46re
else
tmp = 0.0d0 - (x_46re / y_46im)
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -2e-83) {
tmp = -1.0 / (y_46_im / x_46_re);
} else if (y_46_im <= 1.4e-14) {
tmp = x_46_im / y_46_re;
} else {
tmp = 0.0 - (x_46_re / y_46_im);
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if y_46_im <= -2e-83: tmp = -1.0 / (y_46_im / x_46_re) elif y_46_im <= 1.4e-14: tmp = x_46_im / y_46_re else: tmp = 0.0 - (x_46_re / y_46_im) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -2e-83) tmp = Float64(-1.0 / Float64(y_46_im / x_46_re)); elseif (y_46_im <= 1.4e-14) tmp = Float64(x_46_im / y_46_re); else tmp = Float64(0.0 - Float64(x_46_re / y_46_im)); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (y_46_im <= -2e-83) tmp = -1.0 / (y_46_im / x_46_re); elseif (y_46_im <= 1.4e-14) tmp = x_46_im / y_46_re; else tmp = 0.0 - (x_46_re / y_46_im); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -2e-83], N[(-1.0 / N[(y$46$im / x$46$re), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.4e-14], N[(x$46$im / y$46$re), $MachinePrecision], N[(0.0 - N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -2 \cdot 10^{-83}:\\
\;\;\;\;\frac{-1}{\frac{y.im}{x.re}}\\
\mathbf{elif}\;y.im \leq 1.4 \cdot 10^{-14}:\\
\;\;\;\;\frac{x.im}{y.re}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x.re}{y.im}\\
\end{array}
\end{array}
if y.im < -2.0000000000000001e-83Initial program 61.0%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/A
associate-/l*N/A
mul-1-negN/A
accelerator-lowering-fma.f64N/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6471.2
Simplified71.2%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6459.1
Simplified59.1%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr59.6%
if -2.0000000000000001e-83 < y.im < 1.4e-14Initial program 62.6%
Taylor expanded in y.re around inf
/-lowering-/.f6470.5
Simplified70.5%
if 1.4e-14 < y.im Initial program 45.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6484.6
Simplified84.6%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6472.3
Simplified72.3%
+-lft-identityN/A
sub0-negN/A
neg-lowering-neg.f64N/A
+-lft-identity72.3
Applied egg-rr72.3%
Final simplification67.7%
(FPCore (x.re x.im y.re y.im) :precision binary64 (let* ((t_0 (- 0.0 (/ x.re y.im)))) (if (<= y.im -2e-83) t_0 (if (<= y.im 1.1e-15) (/ x.im y.re) t_0))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = 0.0 - (x_46_re / y_46_im);
double tmp;
if (y_46_im <= -2e-83) {
tmp = t_0;
} else if (y_46_im <= 1.1e-15) {
tmp = x_46_im / y_46_re;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: t_0
real(8) :: tmp
t_0 = 0.0d0 - (x_46re / y_46im)
if (y_46im <= (-2d-83)) then
tmp = t_0
else if (y_46im <= 1.1d-15) then
tmp = x_46im / y_46re
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = 0.0 - (x_46_re / y_46_im);
double tmp;
if (y_46_im <= -2e-83) {
tmp = t_0;
} else if (y_46_im <= 1.1e-15) {
tmp = x_46_im / y_46_re;
} else {
tmp = t_0;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = 0.0 - (x_46_re / y_46_im) tmp = 0 if y_46_im <= -2e-83: tmp = t_0 elif y_46_im <= 1.1e-15: tmp = x_46_im / y_46_re else: tmp = t_0 return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(0.0 - Float64(x_46_re / y_46_im)) tmp = 0.0 if (y_46_im <= -2e-83) tmp = t_0; elseif (y_46_im <= 1.1e-15) tmp = Float64(x_46_im / y_46_re); else tmp = t_0; end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = 0.0 - (x_46_re / y_46_im); tmp = 0.0; if (y_46_im <= -2e-83) tmp = t_0; elseif (y_46_im <= 1.1e-15) tmp = x_46_im / y_46_re; else tmp = t_0; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(0.0 - N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$im, -2e-83], t$95$0, If[LessEqual[y$46$im, 1.1e-15], N[(x$46$im / y$46$re), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 0 - \frac{x.re}{y.im}\\
\mathbf{if}\;y.im \leq -2 \cdot 10^{-83}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.im \leq 1.1 \cdot 10^{-15}:\\
\;\;\;\;\frac{x.im}{y.re}\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y.im < -2.0000000000000001e-83 or 1.09999999999999993e-15 < y.im Initial program 53.6%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6477.7
Simplified77.7%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6465.6
Simplified65.6%
+-lft-identityN/A
sub0-negN/A
neg-lowering-neg.f64N/A
+-lft-identity65.6
Applied egg-rr65.6%
if -2.0000000000000001e-83 < y.im < 1.09999999999999993e-15Initial program 62.6%
Taylor expanded in y.re around inf
/-lowering-/.f6470.5
Simplified70.5%
Final simplification67.6%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (<= y.im -4.2e+218) (/ x.re y.im) (if (<= y.im 2.6e+174) (/ x.im y.re) (/ x.re y.im))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -4.2e+218) {
tmp = x_46_re / y_46_im;
} else if (y_46_im <= 2.6e+174) {
tmp = x_46_im / y_46_re;
} else {
tmp = x_46_re / y_46_im;
}
return tmp;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
real(8) :: tmp
if (y_46im <= (-4.2d+218)) then
tmp = x_46re / y_46im
else if (y_46im <= 2.6d+174) then
tmp = x_46im / y_46re
else
tmp = x_46re / y_46im
end if
code = tmp
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_im <= -4.2e+218) {
tmp = x_46_re / y_46_im;
} else if (y_46_im <= 2.6e+174) {
tmp = x_46_im / y_46_re;
} else {
tmp = x_46_re / y_46_im;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if y_46_im <= -4.2e+218: tmp = x_46_re / y_46_im elif y_46_im <= 2.6e+174: tmp = x_46_im / y_46_re else: tmp = x_46_re / y_46_im return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_im <= -4.2e+218) tmp = Float64(x_46_re / y_46_im); elseif (y_46_im <= 2.6e+174) tmp = Float64(x_46_im / y_46_re); else tmp = Float64(x_46_re / y_46_im); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0; if (y_46_im <= -4.2e+218) tmp = x_46_re / y_46_im; elseif (y_46_im <= 2.6e+174) tmp = x_46_im / y_46_re; else tmp = x_46_re / y_46_im; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$im, -4.2e+218], N[(x$46$re / y$46$im), $MachinePrecision], If[LessEqual[y$46$im, 2.6e+174], N[(x$46$im / y$46$re), $MachinePrecision], N[(x$46$re / y$46$im), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -4.2 \cdot 10^{+218}:\\
\;\;\;\;\frac{x.re}{y.im}\\
\mathbf{elif}\;y.im \leq 2.6 \cdot 10^{+174}:\\
\;\;\;\;\frac{x.im}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re}{y.im}\\
\end{array}
\end{array}
if y.im < -4.1999999999999998e218 or 2.5999999999999999e174 < y.im Initial program 30.9%
Taylor expanded in y.re around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
unpow2N/A
associate-/r*N/A
div-subN/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/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--.f6498.2
Simplified98.2%
Taylor expanded in y.re around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6488.0
Simplified88.0%
frac-2negN/A
flip3--N/A
distribute-neg-fracN/A
metadata-evalN/A
sub0-negN/A
cube-negN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
+-lft-identityN/A
+-lft-identityN/A
pow-prod-downN/A
sqr-powN/A
+-lft-identityN/A
sub0-negN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
Applied egg-rr32.0%
if -4.1999999999999998e218 < y.im < 2.5999999999999999e174Initial program 64.0%
Taylor expanded in y.re around inf
/-lowering-/.f6448.2
Simplified48.2%
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ x.im y.re))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return x_46_im / y_46_re;
}
real(8) function code(x_46re, x_46im, y_46re, y_46im)
real(8), intent (in) :: x_46re
real(8), intent (in) :: x_46im
real(8), intent (in) :: y_46re
real(8), intent (in) :: y_46im
code = x_46im / y_46re
end function
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
return x_46_im / y_46_re;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): return x_46_im / y_46_re
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(x_46_im / y_46_re) end
function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = x_46_im / y_46_re; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(x$46$im / y$46$re), $MachinePrecision]
\begin{array}{l}
\\
\frac{x.im}{y.re}
\end{array}
Initial program 57.3%
Taylor expanded in y.re around inf
/-lowering-/.f6439.6
Simplified39.6%
herbie shell --seed 2024194
(FPCore (x.re x.im y.re y.im)
:name "_divideComplex, imaginary part"
:precision binary64
(/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))