
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ (+ (* x.re y.re) (* x.im 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_re * y_46_re) + (x_46_im * 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_46re * y_46re) + (x_46im * 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_re * y_46_re) + (x_46_im * 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_re * y_46_re) + (x_46_im * 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_re * y_46_re) + Float64(x_46_im * 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_re * y_46_re) + (x_46_im * 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$re * y$46$re), $MachinePrecision] + N[(x$46$im * 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.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 14 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ (+ (* x.re y.re) (* x.im 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_re * y_46_re) + (x_46_im * 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_46re * y_46re) + (x_46im * 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_re * y_46_re) + (x_46_im * 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_re * y_46_re) + (x_46_im * 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_re * y_46_re) + Float64(x_46_im * 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_re * y_46_re) + (x_46_im * 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$re * y$46$re), $MachinePrecision] + N[(x$46$im * 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.re \cdot y.re + x.im \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
(if (<=
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))
2e+251)
(*
(/ 1.0 (hypot y.re y.im))
(/ (fma x.re y.re (* x.im y.im)) (hypot y.re y.im)))
(*
(/ (+ y.im (* x.re (/ y.re x.im))) (hypot y.re y.im))
(/ x.im (hypot y.re y.im)))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if ((((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im))) <= 2e+251) {
tmp = (1.0 / hypot(y_46_re, y_46_im)) * (fma(x_46_re, y_46_re, (x_46_im * y_46_im)) / hypot(y_46_re, y_46_im));
} else {
tmp = ((y_46_im + (x_46_re * (y_46_re / x_46_im))) / hypot(y_46_re, y_46_im)) * (x_46_im / hypot(y_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 (Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) <= 2e+251) tmp = Float64(Float64(1.0 / hypot(y_46_re, y_46_im)) * Float64(fma(x_46_re, y_46_re, Float64(x_46_im * y_46_im)) / hypot(y_46_re, y_46_im))); else tmp = Float64(Float64(Float64(y_46_im + Float64(x_46_re * Float64(y_46_re / x_46_im))) / hypot(y_46_re, y_46_im)) * Float64(x_46_im / hypot(y_46_re, y_46_im))); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e+251], N[(N[(1.0 / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(x$46$re * y$46$re + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y$46$im + N[(x$46$re * N[(y$46$re / x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision] * N[(x$46$im / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \leq 2 \cdot 10^{+251}:\\
\;\;\;\;\frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.re, y.re, x.im \cdot y.im\right)}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{y.im + x.re \cdot \frac{y.re}{x.im}}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{x.im}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\end{array}
\end{array}
if (/.f64 (+.f64 (*.f64 x.re y.re) (*.f64 x.im y.im)) (+.f64 (*.f64 y.re y.re) (*.f64 y.im y.im))) < 2.0000000000000001e251Initial program 76.2%
fma-define76.2%
fma-define76.2%
Simplified76.2%
*-un-lft-identity76.2%
fma-define76.2%
add-sqr-sqrt76.2%
times-frac76.3%
fma-define76.3%
hypot-define76.3%
fma-define76.3%
fma-define76.3%
hypot-define96.1%
Applied egg-rr96.1%
if 2.0000000000000001e251 < (/.f64 (+.f64 (*.f64 x.re y.re) (*.f64 x.im y.im)) (+.f64 (*.f64 y.re y.re) (*.f64 y.im y.im))) Initial program 14.9%
fma-define14.9%
fma-define14.9%
Simplified14.9%
Taylor expanded in x.im around inf 14.9%
associate-/l*13.6%
Simplified13.6%
*-commutative13.6%
fma-undefine13.6%
add-sqr-sqrt13.6%
hypot-undefine13.6%
hypot-undefine13.6%
times-frac75.6%
+-commutative75.6%
fma-define75.6%
Applied egg-rr75.6%
fma-undefine75.6%
Applied egg-rr75.6%
Final simplification90.0%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.re -1.4e+75)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re -6.8e-114)
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))
(if (<= y.re 1.26e-50)
(/ (+ x.im (* y.re (/ x.re y.im))) y.im)
(if (<= y.re 3e+142)
(/ (fma x.re y.re (* x.im y.im)) (fma y.re y.re (* y.im y.im)))
(/ (+ x.re (* x.im (/ y.im y.re))) (hypot y.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_re <= -1.4e+75) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -6.8e-114) {
tmp = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
} else if (y_46_re <= 1.26e-50) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 3e+142) {
tmp = fma(x_46_re, y_46_re, (x_46_im * y_46_im)) / fma(y_46_re, y_46_re, (y_46_im * y_46_im));
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / hypot(y_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_re <= -1.4e+75) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= -6.8e-114) tmp = Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))); elseif (y_46_re <= 1.26e-50) tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / y_46_im); elseif (y_46_re <= 3e+142) tmp = Float64(fma(x_46_re, y_46_re, Float64(x_46_im * y_46_im)) / fma(y_46_re, y_46_re, Float64(y_46_im * y_46_im))); else tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / hypot(y_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$re, -1.4e+75], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, -6.8e-114], N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.26e-50], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 3e+142], N[(N[(x$46$re * y$46$re + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(y$46$re * y$46$re + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -1.4 \cdot 10^{+75}:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq -6.8 \cdot 10^{-114}:\\
\;\;\;\;\frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}\\
\mathbf{elif}\;y.re \leq 1.26 \cdot 10^{-50}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\mathbf{elif}\;y.re \leq 3 \cdot 10^{+142}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x.re, y.re, x.im \cdot y.im\right)}{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\end{array}
\end{array}
if y.re < -1.40000000000000006e75Initial program 30.5%
fma-define30.5%
fma-define30.5%
Simplified30.5%
*-un-lft-identity30.5%
fma-define30.5%
add-sqr-sqrt30.5%
times-frac30.5%
fma-define30.5%
hypot-define30.5%
fma-define30.5%
fma-define30.5%
hypot-define52.3%
Applied egg-rr52.3%
Taylor expanded in y.re around -inf 75.1%
distribute-lft-out75.1%
associate-/l*82.7%
Simplified82.7%
Taylor expanded in y.re around -inf 80.4%
clear-num80.5%
un-div-inv80.4%
Applied egg-rr80.4%
associate-/r/83.7%
Simplified83.7%
if -1.40000000000000006e75 < y.re < -6.79999999999999962e-114Initial program 89.7%
if -6.79999999999999962e-114 < y.re < 1.26e-50Initial program 64.4%
fma-define64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in y.im around inf 89.7%
*-commutative89.7%
*-un-lft-identity89.7%
times-frac89.8%
Applied egg-rr89.8%
if 1.26e-50 < y.re < 2.99999999999999975e142Initial program 69.4%
fma-define69.4%
fma-define69.5%
Simplified69.5%
if 2.99999999999999975e142 < y.re Initial program 23.1%
fma-define23.1%
fma-define23.1%
Simplified23.1%
*-un-lft-identity23.1%
fma-define23.1%
add-sqr-sqrt23.1%
times-frac23.1%
fma-define23.1%
hypot-define23.1%
fma-define23.1%
fma-define23.1%
hypot-define63.3%
Applied egg-rr63.3%
Taylor expanded in y.re around -inf 23.2%
distribute-lft-out23.2%
associate-/l*23.2%
Simplified23.2%
associate-*l/23.2%
*-un-lft-identity23.2%
add-sqr-sqrt10.6%
sqrt-unprod54.8%
mul-1-neg54.8%
mul-1-neg54.8%
sqr-neg54.8%
sqrt-unprod59.0%
add-sqr-sqrt97.6%
+-commutative97.6%
fma-define97.6%
Applied egg-rr97.6%
fma-undefine97.6%
Applied egg-rr97.6%
Final simplification86.8%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.re -5.5e+75)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re -3.8e-106)
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))
(if (<= y.re 7.8e+115)
(*
(/ (+ y.im (* x.re (/ y.re x.im))) (hypot y.re y.im))
(/ x.im (hypot y.re y.im)))
(/ (+ x.re (* x.im (/ y.im y.re))) (hypot y.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_re <= -5.5e+75) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -3.8e-106) {
tmp = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
} else if (y_46_re <= 7.8e+115) {
tmp = ((y_46_im + (x_46_re * (y_46_re / x_46_im))) / hypot(y_46_re, y_46_im)) * (x_46_im / hypot(y_46_re, y_46_im));
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / hypot(y_46_re, y_46_im);
}
return tmp;
}
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_re <= -5.5e+75) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -3.8e-106) {
tmp = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
} else if (y_46_re <= 7.8e+115) {
tmp = ((y_46_im + (x_46_re * (y_46_re / x_46_im))) / Math.hypot(y_46_re, y_46_im)) * (x_46_im / Math.hypot(y_46_re, y_46_im));
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / Math.hypot(y_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_re <= -5.5e+75: tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))) elif y_46_re <= -3.8e-106: tmp = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)) elif y_46_re <= 7.8e+115: tmp = ((y_46_im + (x_46_re * (y_46_re / x_46_im))) / math.hypot(y_46_re, y_46_im)) * (x_46_im / math.hypot(y_46_re, y_46_im)) else: tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / math.hypot(y_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_re <= -5.5e+75) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= -3.8e-106) tmp = Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))); elseif (y_46_re <= 7.8e+115) tmp = Float64(Float64(Float64(y_46_im + Float64(x_46_re * Float64(y_46_re / x_46_im))) / hypot(y_46_re, y_46_im)) * Float64(x_46_im / hypot(y_46_re, y_46_im))); else tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / hypot(y_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_re <= -5.5e+75) tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))); elseif (y_46_re <= -3.8e-106) tmp = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)); elseif (y_46_re <= 7.8e+115) tmp = ((y_46_im + (x_46_re * (y_46_re / x_46_im))) / hypot(y_46_re, y_46_im)) * (x_46_im / hypot(y_46_re, y_46_im)); else tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / hypot(y_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$re, -5.5e+75], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, -3.8e-106], N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 7.8e+115], N[(N[(N[(y$46$im + N[(x$46$re * N[(y$46$re / x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision] * N[(x$46$im / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -5.5 \cdot 10^{+75}:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq -3.8 \cdot 10^{-106}:\\
\;\;\;\;\frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}\\
\mathbf{elif}\;y.re \leq 7.8 \cdot 10^{+115}:\\
\;\;\;\;\frac{y.im + x.re \cdot \frac{y.re}{x.im}}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{x.im}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\end{array}
\end{array}
if y.re < -5.5000000000000001e75Initial program 30.5%
fma-define30.5%
fma-define30.5%
Simplified30.5%
*-un-lft-identity30.5%
fma-define30.5%
add-sqr-sqrt30.5%
times-frac30.5%
fma-define30.5%
hypot-define30.5%
fma-define30.5%
fma-define30.5%
hypot-define52.3%
Applied egg-rr52.3%
Taylor expanded in y.re around -inf 75.1%
distribute-lft-out75.1%
associate-/l*82.7%
Simplified82.7%
Taylor expanded in y.re around -inf 80.4%
clear-num80.5%
un-div-inv80.4%
Applied egg-rr80.4%
associate-/r/83.7%
Simplified83.7%
if -5.5000000000000001e75 < y.re < -3.7999999999999999e-106Initial program 90.4%
if -3.7999999999999999e-106 < y.re < 7.80000000000000012e115Initial program 65.6%
fma-define65.6%
fma-define65.6%
Simplified65.6%
Taylor expanded in x.im around inf 61.2%
associate-/l*59.8%
Simplified59.8%
*-commutative59.8%
fma-undefine59.8%
add-sqr-sqrt59.8%
hypot-undefine59.8%
hypot-undefine59.8%
times-frac91.2%
+-commutative91.2%
fma-define91.2%
Applied egg-rr91.2%
fma-undefine91.2%
Applied egg-rr91.2%
if 7.80000000000000012e115 < y.re Initial program 29.0%
fma-define29.0%
fma-define29.0%
Simplified29.0%
*-un-lft-identity29.0%
fma-define29.0%
add-sqr-sqrt29.0%
times-frac29.0%
fma-define29.0%
hypot-define29.0%
fma-define29.0%
fma-define29.0%
hypot-define67.3%
Applied egg-rr67.3%
Taylor expanded in y.re around -inf 23.7%
distribute-lft-out23.7%
associate-/l*23.8%
Simplified23.8%
associate-*l/23.8%
*-un-lft-identity23.8%
add-sqr-sqrt12.4%
sqrt-unprod54.6%
mul-1-neg54.6%
mul-1-neg54.6%
sqr-neg54.6%
sqrt-unprod55.4%
add-sqr-sqrt92.6%
+-commutative92.6%
fma-define92.6%
Applied egg-rr92.6%
fma-undefine92.6%
Applied egg-rr92.6%
Final simplification89.9%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))))
(if (<= y.re -5.5e+72)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re -6.1e-114)
t_0
(if (<= y.re 3.25e-52)
(/ (+ x.im (* y.re (/ x.re y.im))) y.im)
(if (<= y.re 3.5e+142)
t_0
(/ (+ x.re (* x.im (/ y.im y.re))) (hypot y.re y.im))))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
double tmp;
if (y_46_re <= -5.5e+72) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -6.1e-114) {
tmp = t_0;
} else if (y_46_re <= 3.25e-52) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 3.5e+142) {
tmp = t_0;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / hypot(y_46_re, y_46_im);
}
return tmp;
}
public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
double tmp;
if (y_46_re <= -5.5e+72) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -6.1e-114) {
tmp = t_0;
} else if (y_46_re <= 3.25e-52) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 3.5e+142) {
tmp = t_0;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / Math.hypot(y_46_re, y_46_im);
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)) tmp = 0 if y_46_re <= -5.5e+72: tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))) elif y_46_re <= -6.1e-114: tmp = t_0 elif y_46_re <= 3.25e-52: tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im elif y_46_re <= 3.5e+142: tmp = t_0 else: tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / math.hypot(y_46_re, y_46_im) return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) tmp = 0.0 if (y_46_re <= -5.5e+72) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= -6.1e-114) tmp = t_0; elseif (y_46_re <= 3.25e-52) tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / y_46_im); elseif (y_46_re <= 3.5e+142) tmp = t_0; else tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / hypot(y_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) t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)); tmp = 0.0; if (y_46_re <= -5.5e+72) tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))); elseif (y_46_re <= -6.1e-114) tmp = t_0; elseif (y_46_re <= 3.25e-52) tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im; elseif (y_46_re <= 3.5e+142) tmp = t_0; else tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / hypot(y_46_re, y_46_im); end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -5.5e+72], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, -6.1e-114], t$95$0, If[LessEqual[y$46$re, 3.25e-52], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 3.5e+142], t$95$0, N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}\\
\mathbf{if}\;y.re \leq -5.5 \cdot 10^{+72}:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq -6.1 \cdot 10^{-114}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.re \leq 3.25 \cdot 10^{-52}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\mathbf{elif}\;y.re \leq 3.5 \cdot 10^{+142}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{\mathsf{hypot}\left(y.re, y.im\right)}\\
\end{array}
\end{array}
if y.re < -5.5e72Initial program 30.5%
fma-define30.5%
fma-define30.5%
Simplified30.5%
*-un-lft-identity30.5%
fma-define30.5%
add-sqr-sqrt30.5%
times-frac30.5%
fma-define30.5%
hypot-define30.5%
fma-define30.5%
fma-define30.5%
hypot-define52.3%
Applied egg-rr52.3%
Taylor expanded in y.re around -inf 75.1%
distribute-lft-out75.1%
associate-/l*82.7%
Simplified82.7%
Taylor expanded in y.re around -inf 80.4%
clear-num80.5%
un-div-inv80.4%
Applied egg-rr80.4%
associate-/r/83.7%
Simplified83.7%
if -5.5e72 < y.re < -6.09999999999999977e-114 or 3.25e-52 < y.re < 3.49999999999999997e142Initial program 80.2%
if -6.09999999999999977e-114 < y.re < 3.25e-52Initial program 64.4%
fma-define64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in y.im around inf 89.7%
*-commutative89.7%
*-un-lft-identity89.7%
times-frac89.8%
Applied egg-rr89.8%
if 3.49999999999999997e142 < y.re Initial program 23.1%
fma-define23.1%
fma-define23.1%
Simplified23.1%
*-un-lft-identity23.1%
fma-define23.1%
add-sqr-sqrt23.1%
times-frac23.1%
fma-define23.1%
hypot-define23.1%
fma-define23.1%
fma-define23.1%
hypot-define63.3%
Applied egg-rr63.3%
Taylor expanded in y.re around -inf 23.2%
distribute-lft-out23.2%
associate-/l*23.2%
Simplified23.2%
associate-*l/23.2%
*-un-lft-identity23.2%
add-sqr-sqrt10.6%
sqrt-unprod54.8%
mul-1-neg54.8%
mul-1-neg54.8%
sqr-neg54.8%
sqrt-unprod59.0%
add-sqr-sqrt97.6%
+-commutative97.6%
fma-define97.6%
Applied egg-rr97.6%
fma-undefine97.6%
Applied egg-rr97.6%
Final simplification86.8%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))))
(if (<= y.re -2.65e+76)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re -6.8e-114)
t_0
(if (<= y.re 3.25e-52)
(/ (+ x.im (* y.re (/ x.re y.im))) y.im)
(if (<= y.re 8e+142) t_0 (/ (fma x.im (/ y.im y.re) x.re) y.re)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
double tmp;
if (y_46_re <= -2.65e+76) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -6.8e-114) {
tmp = t_0;
} else if (y_46_re <= 3.25e-52) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 8e+142) {
tmp = t_0;
} else {
tmp = fma(x_46_im, (y_46_im / y_46_re), x_46_re) / y_46_re;
}
return tmp;
}
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) tmp = 0.0 if (y_46_re <= -2.65e+76) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= -6.8e-114) tmp = t_0; elseif (y_46_re <= 3.25e-52) tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / y_46_im); elseif (y_46_re <= 8e+142) tmp = t_0; else tmp = Float64(fma(x_46_im, Float64(y_46_im / y_46_re), x_46_re) / y_46_re); end return tmp end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -2.65e+76], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, -6.8e-114], t$95$0, If[LessEqual[y$46$re, 3.25e-52], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 8e+142], t$95$0, N[(N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision] + x$46$re), $MachinePrecision] / y$46$re), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}\\
\mathbf{if}\;y.re \leq -2.65 \cdot 10^{+76}:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq -6.8 \cdot 10^{-114}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.re \leq 3.25 \cdot 10^{-52}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\mathbf{elif}\;y.re \leq 8 \cdot 10^{+142}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x.im, \frac{y.im}{y.re}, x.re\right)}{y.re}\\
\end{array}
\end{array}
if y.re < -2.65000000000000008e76Initial program 30.5%
fma-define30.5%
fma-define30.5%
Simplified30.5%
*-un-lft-identity30.5%
fma-define30.5%
add-sqr-sqrt30.5%
times-frac30.5%
fma-define30.5%
hypot-define30.5%
fma-define30.5%
fma-define30.5%
hypot-define52.3%
Applied egg-rr52.3%
Taylor expanded in y.re around -inf 75.1%
distribute-lft-out75.1%
associate-/l*82.7%
Simplified82.7%
Taylor expanded in y.re around -inf 80.4%
clear-num80.5%
un-div-inv80.4%
Applied egg-rr80.4%
associate-/r/83.7%
Simplified83.7%
if -2.65000000000000008e76 < y.re < -6.79999999999999962e-114 or 3.25e-52 < y.re < 8.00000000000000041e142Initial program 80.2%
if -6.79999999999999962e-114 < y.re < 3.25e-52Initial program 64.4%
fma-define64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in y.im around inf 89.7%
*-commutative89.7%
*-un-lft-identity89.7%
times-frac89.8%
Applied egg-rr89.8%
if 8.00000000000000041e142 < y.re Initial program 23.1%
fma-define23.1%
fma-define23.1%
Simplified23.1%
Taylor expanded in y.re around inf 85.3%
+-commutative85.3%
associate-/l*97.5%
fma-define97.5%
Simplified97.5%
Final simplification86.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(let* ((t_0
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im)))))
(if (<= y.re -1.35e+73)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re -5.2e-114)
t_0
(if (<= y.re 6.6e-52)
(/ (+ x.im (* y.re (/ x.re y.im))) y.im)
(if (<= y.re 2.4e+144)
t_0
(/ (+ x.re (* x.im (/ y.im y.re))) y.re)))))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
double tmp;
if (y_46_re <= -1.35e+73) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -5.2e-114) {
tmp = t_0;
} else if (y_46_re <= 6.6e-52) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 2.4e+144) {
tmp = t_0;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
}
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 = ((x_46re * y_46re) + (x_46im * y_46im)) / ((y_46re * y_46re) + (y_46im * y_46im))
if (y_46re <= (-1.35d+73)) then
tmp = ((-1.0d0) / y_46re) * (-x_46re - (y_46im * (x_46im / y_46re)))
else if (y_46re <= (-5.2d-114)) then
tmp = t_0
else if (y_46re <= 6.6d-52) then
tmp = (x_46im + (y_46re * (x_46re / y_46im))) / y_46im
else if (y_46re <= 2.4d+144) then
tmp = t_0
else
tmp = (x_46re + (x_46im * (y_46im / y_46re))) / y_46re
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 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
double tmp;
if (y_46_re <= -1.35e+73) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= -5.2e-114) {
tmp = t_0;
} else if (y_46_re <= 6.6e-52) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else if (y_46_re <= 2.4e+144) {
tmp = t_0;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)) tmp = 0 if y_46_re <= -1.35e+73: tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))) elif y_46_re <= -5.2e-114: tmp = t_0 elif y_46_re <= 6.6e-52: tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im elif y_46_re <= 2.4e+144: tmp = t_0 else: tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = Float64(Float64(Float64(x_46_re * y_46_re) + Float64(x_46_im * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im))) tmp = 0.0 if (y_46_re <= -1.35e+73) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= -5.2e-114) tmp = t_0; elseif (y_46_re <= 6.6e-52) tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / y_46_im); elseif (y_46_re <= 2.4e+144) tmp = t_0; else tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / y_46_re); end return tmp end
function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im) t_0 = ((x_46_re * y_46_re) + (x_46_im * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im)); tmp = 0.0; if (y_46_re <= -1.35e+73) tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))); elseif (y_46_re <= -5.2e-114) tmp = t_0; elseif (y_46_re <= 6.6e-52) tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im; elseif (y_46_re <= 2.4e+144) tmp = t_0; else tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[(N[(x$46$re * y$46$re), $MachinePrecision] + N[(x$46$im * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -1.35e+73], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, -5.2e-114], t$95$0, If[LessEqual[y$46$re, 6.6e-52], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$re, 2.4e+144], t$95$0, N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x.re \cdot y.re + x.im \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im}\\
\mathbf{if}\;y.re \leq -1.35 \cdot 10^{+73}:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq -5.2 \cdot 10^{-114}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y.re \leq 6.6 \cdot 10^{-52}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\mathbf{elif}\;y.re \leq 2.4 \cdot 10^{+144}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{y.re}\\
\end{array}
\end{array}
if y.re < -1.35e73Initial program 30.5%
fma-define30.5%
fma-define30.5%
Simplified30.5%
*-un-lft-identity30.5%
fma-define30.5%
add-sqr-sqrt30.5%
times-frac30.5%
fma-define30.5%
hypot-define30.5%
fma-define30.5%
fma-define30.5%
hypot-define52.3%
Applied egg-rr52.3%
Taylor expanded in y.re around -inf 75.1%
distribute-lft-out75.1%
associate-/l*82.7%
Simplified82.7%
Taylor expanded in y.re around -inf 80.4%
clear-num80.5%
un-div-inv80.4%
Applied egg-rr80.4%
associate-/r/83.7%
Simplified83.7%
if -1.35e73 < y.re < -5.20000000000000026e-114 or 6.5999999999999999e-52 < y.re < 2.4000000000000001e144Initial program 80.2%
if -5.20000000000000026e-114 < y.re < 6.5999999999999999e-52Initial program 64.4%
fma-define64.4%
fma-define64.4%
Simplified64.4%
Taylor expanded in y.im around inf 89.7%
*-commutative89.7%
*-un-lft-identity89.7%
times-frac89.8%
Applied egg-rr89.8%
if 2.4000000000000001e144 < y.re Initial program 23.1%
fma-define23.1%
fma-define23.1%
Simplified23.1%
*-un-lft-identity23.1%
fma-define23.1%
add-sqr-sqrt23.1%
times-frac23.1%
fma-define23.1%
hypot-define23.1%
fma-define23.1%
fma-define23.1%
hypot-define63.3%
Applied egg-rr63.3%
Taylor expanded in y.re around inf 85.3%
associate-/l*97.5%
Simplified97.5%
Final simplification86.7%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (or (<= y.re -1950000.0) (not (<= y.re 2.6e-50))) (/ (+ x.re (* x.im (/ y.im y.re))) y.re) (/ (+ x.im (/ (* x.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) {
double tmp;
if ((y_46_re <= -1950000.0) || !(y_46_re <= 2.6e-50)) {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / 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_46re <= (-1950000.0d0)) .or. (.not. (y_46re <= 2.6d-50))) then
tmp = (x_46re + (x_46im * (y_46im / y_46re))) / y_46re
else
tmp = (x_46im + ((x_46re * y_46re) / y_46im)) / 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_re <= -1950000.0) || !(y_46_re <= 2.6e-50)) {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
} else {
tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / y_46_im;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if (y_46_re <= -1950000.0) or not (y_46_re <= 2.6e-50): tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re else: tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / 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_re <= -1950000.0) || !(y_46_re <= 2.6e-50)) tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / y_46_re); else tmp = Float64(Float64(x_46_im + Float64(Float64(x_46_re * y_46_re) / y_46_im)) / 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_re <= -1950000.0) || ~((y_46_re <= 2.6e-50))) tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re; else tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / y_46_im; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$re, -1950000.0], N[Not[LessEqual[y$46$re, 2.6e-50]], $MachinePrecision]], N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(N[(x$46$im + N[(N[(x$46$re * y$46$re), $MachinePrecision] / y$46$im), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -1950000 \lor \neg \left(y.re \leq 2.6 \cdot 10^{-50}\right):\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.im + \frac{x.re \cdot y.re}{y.im}}{y.im}\\
\end{array}
\end{array}
if y.re < -1.95e6 or 2.6000000000000001e-50 < y.re Initial program 46.5%
fma-define46.5%
fma-define46.5%
Simplified46.5%
*-un-lft-identity46.5%
fma-define46.5%
add-sqr-sqrt46.5%
times-frac46.5%
fma-define46.5%
hypot-define46.5%
fma-define46.5%
fma-define46.5%
hypot-define68.5%
Applied egg-rr68.5%
Taylor expanded in y.re around inf 70.3%
associate-/l*76.0%
Simplified76.0%
if -1.95e6 < y.re < 2.6000000000000001e-50Initial program 69.6%
fma-define69.6%
fma-define69.6%
Simplified69.6%
Taylor expanded in y.im around inf 85.6%
Final simplification80.7%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (or (<= y.re -2400000.0) (not (<= y.re 3.5e+116))) (/ x.re y.re) (/ (+ x.im (/ (* x.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) {
double tmp;
if ((y_46_re <= -2400000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / 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_46re <= (-2400000.0d0)) .or. (.not. (y_46re <= 3.5d+116))) then
tmp = x_46re / y_46re
else
tmp = (x_46im + ((x_46re * y_46re) / y_46im)) / 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_re <= -2400000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / y_46_im;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if (y_46_re <= -2400000.0) or not (y_46_re <= 3.5e+116): tmp = x_46_re / y_46_re else: tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / 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_re <= -2400000.0) || !(y_46_re <= 3.5e+116)) tmp = Float64(x_46_re / y_46_re); else tmp = Float64(Float64(x_46_im + Float64(Float64(x_46_re * y_46_re) / y_46_im)) / 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_re <= -2400000.0) || ~((y_46_re <= 3.5e+116))) tmp = x_46_re / y_46_re; else tmp = (x_46_im + ((x_46_re * y_46_re) / y_46_im)) / y_46_im; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$re, -2400000.0], N[Not[LessEqual[y$46$re, 3.5e+116]], $MachinePrecision]], N[(x$46$re / y$46$re), $MachinePrecision], N[(N[(x$46$im + N[(N[(x$46$re * y$46$re), $MachinePrecision] / y$46$im), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -2400000 \lor \neg \left(y.re \leq 3.5 \cdot 10^{+116}\right):\\
\;\;\;\;\frac{x.re}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.im + \frac{x.re \cdot y.re}{y.im}}{y.im}\\
\end{array}
\end{array}
if y.re < -2.4e6 or 3.49999999999999997e116 < y.re Initial program 39.7%
fma-define39.7%
fma-define39.7%
Simplified39.7%
Taylor expanded in y.re around inf 70.1%
if -2.4e6 < y.re < 3.49999999999999997e116Initial program 69.0%
fma-define69.0%
fma-define69.0%
Simplified69.0%
Taylor expanded in y.im around inf 78.0%
Final simplification75.0%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (or (<= y.re -2200000.0) (not (<= y.re 3.5e+116))) (/ x.re y.re) (/ (+ x.im (/ x.re (/ y.im y.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_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + (x_46_re / (y_46_im / y_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_46re <= (-2200000.0d0)) .or. (.not. (y_46re <= 3.5d+116))) then
tmp = x_46re / y_46re
else
tmp = (x_46im + (x_46re / (y_46im / y_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_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + (x_46_re / (y_46_im / y_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_re <= -2200000.0) or not (y_46_re <= 3.5e+116): tmp = x_46_re / y_46_re else: tmp = (x_46_im + (x_46_re / (y_46_im / y_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_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) tmp = Float64(x_46_re / y_46_re); else tmp = Float64(Float64(x_46_im + Float64(x_46_re / Float64(y_46_im / y_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_re <= -2200000.0) || ~((y_46_re <= 3.5e+116))) tmp = x_46_re / y_46_re; else tmp = (x_46_im + (x_46_re / (y_46_im / y_46_re))) / y_46_im; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$re, -2200000.0], N[Not[LessEqual[y$46$re, 3.5e+116]], $MachinePrecision]], N[(x$46$re / y$46$re), $MachinePrecision], N[(N[(x$46$im + N[(x$46$re / N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -2200000 \lor \neg \left(y.re \leq 3.5 \cdot 10^{+116}\right):\\
\;\;\;\;\frac{x.re}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.im + \frac{x.re}{\frac{y.im}{y.re}}}{y.im}\\
\end{array}
\end{array}
if y.re < -2.2e6 or 3.49999999999999997e116 < y.re Initial program 39.7%
fma-define39.7%
fma-define39.7%
Simplified39.7%
Taylor expanded in y.re around inf 70.1%
if -2.2e6 < y.re < 3.49999999999999997e116Initial program 69.0%
fma-define69.0%
fma-define69.0%
Simplified69.0%
Taylor expanded in y.im around inf 78.0%
associate-/l*77.5%
Simplified77.5%
clear-num77.5%
un-div-inv77.5%
Applied egg-rr77.5%
Final simplification74.7%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (or (<= y.re -2200000.0) (not (<= y.re 3.5e+116))) (/ x.re y.re) (/ (+ x.im (* x.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) {
double tmp;
if ((y_46_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + (x_46_re * (y_46_re / y_46_im))) / 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_46re <= (-2200000.0d0)) .or. (.not. (y_46re <= 3.5d+116))) then
tmp = x_46re / y_46re
else
tmp = (x_46im + (x_46re * (y_46re / y_46im))) / 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_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) {
tmp = x_46_re / y_46_re;
} else {
tmp = (x_46_im + (x_46_re * (y_46_re / y_46_im))) / y_46_im;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if (y_46_re <= -2200000.0) or not (y_46_re <= 3.5e+116): tmp = x_46_re / y_46_re else: tmp = (x_46_im + (x_46_re * (y_46_re / y_46_im))) / 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_re <= -2200000.0) || !(y_46_re <= 3.5e+116)) tmp = Float64(x_46_re / y_46_re); else tmp = Float64(Float64(x_46_im + Float64(x_46_re * Float64(y_46_re / y_46_im))) / 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_re <= -2200000.0) || ~((y_46_re <= 3.5e+116))) tmp = x_46_re / y_46_re; else tmp = (x_46_im + (x_46_re * (y_46_re / y_46_im))) / y_46_im; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$re, -2200000.0], N[Not[LessEqual[y$46$re, 3.5e+116]], $MachinePrecision]], N[(x$46$re / y$46$re), $MachinePrecision], N[(N[(x$46$im + N[(x$46$re * N[(y$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -2200000 \lor \neg \left(y.re \leq 3.5 \cdot 10^{+116}\right):\\
\;\;\;\;\frac{x.re}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.im + x.re \cdot \frac{y.re}{y.im}}{y.im}\\
\end{array}
\end{array}
if y.re < -2.2e6 or 3.49999999999999997e116 < y.re Initial program 39.7%
fma-define39.7%
fma-define39.7%
Simplified39.7%
Taylor expanded in y.re around inf 70.1%
if -2.2e6 < y.re < 3.49999999999999997e116Initial program 69.0%
fma-define69.0%
fma-define69.0%
Simplified69.0%
Taylor expanded in y.im around inf 78.0%
associate-/l*77.5%
Simplified77.5%
Final simplification74.7%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.re -2400000.0)
(* (/ -1.0 y.re) (- (- x.re) (* y.im (/ x.im y.re))))
(if (<= y.re 3.75e-47)
(/ (+ x.im (* y.re (/ x.re y.im))) y.im)
(/ (+ x.re (* x.im (/ y.im y.re))) y.re))))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if (y_46_re <= -2400000.0) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= 3.75e-47) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
}
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_46re <= (-2400000.0d0)) then
tmp = ((-1.0d0) / y_46re) * (-x_46re - (y_46im * (x_46im / y_46re)))
else if (y_46re <= 3.75d-47) then
tmp = (x_46im + (y_46re * (x_46re / y_46im))) / y_46im
else
tmp = (x_46re + (x_46im * (y_46im / y_46re))) / y_46re
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_re <= -2400000.0) {
tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re)));
} else if (y_46_re <= 3.75e-47) {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im;
} else {
tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if y_46_re <= -2400000.0: tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))) elif y_46_re <= 3.75e-47: tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im else: tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if (y_46_re <= -2400000.0) tmp = Float64(Float64(-1.0 / y_46_re) * Float64(Float64(-x_46_re) - Float64(y_46_im * Float64(x_46_im / y_46_re)))); elseif (y_46_re <= 3.75e-47) tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / y_46_im); else tmp = Float64(Float64(x_46_re + Float64(x_46_im * Float64(y_46_im / y_46_re))) / y_46_re); 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_re <= -2400000.0) tmp = (-1.0 / y_46_re) * (-x_46_re - (y_46_im * (x_46_im / y_46_re))); elseif (y_46_re <= 3.75e-47) tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / y_46_im; else tmp = (x_46_re + (x_46_im * (y_46_im / y_46_re))) / y_46_re; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[LessEqual[y$46$re, -2400000.0], N[(N[(-1.0 / y$46$re), $MachinePrecision] * N[((-x$46$re) - N[(y$46$im * N[(x$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 3.75e-47], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], N[(N[(x$46$re + N[(x$46$im * N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.re \leq -2400000:\\
\;\;\;\;\frac{-1}{y.re} \cdot \left(\left(-x.re\right) - y.im \cdot \frac{x.im}{y.re}\right)\\
\mathbf{elif}\;y.re \leq 3.75 \cdot 10^{-47}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re + x.im \cdot \frac{y.im}{y.re}}{y.re}\\
\end{array}
\end{array}
if y.re < -2.4e6Initial program 45.3%
fma-define45.3%
fma-define45.3%
Simplified45.3%
*-un-lft-identity45.3%
fma-define45.3%
add-sqr-sqrt45.3%
times-frac45.4%
fma-define45.4%
hypot-define45.4%
fma-define45.4%
fma-define45.4%
hypot-define62.8%
Applied egg-rr62.8%
Taylor expanded in y.re around -inf 73.8%
distribute-lft-out73.8%
associate-/l*79.5%
Simplified79.5%
Taylor expanded in y.re around -inf 77.7%
clear-num77.7%
un-div-inv77.7%
Applied egg-rr77.7%
associate-/r/80.1%
Simplified80.1%
if -2.4e6 < y.re < 3.74999999999999984e-47Initial program 69.6%
fma-define69.6%
fma-define69.6%
Simplified69.6%
Taylor expanded in y.im around inf 85.6%
*-commutative85.6%
*-un-lft-identity85.6%
times-frac85.7%
Applied egg-rr85.7%
if 3.74999999999999984e-47 < y.re Initial program 47.6%
fma-define47.6%
fma-define47.6%
Simplified47.6%
*-un-lft-identity47.6%
fma-define47.6%
add-sqr-sqrt47.6%
times-frac47.5%
fma-define47.5%
hypot-define47.6%
fma-define47.6%
fma-define47.6%
hypot-define73.8%
Applied egg-rr73.8%
Taylor expanded in y.re around inf 68.3%
associate-/l*74.1%
Simplified74.1%
Final simplification81.2%
(FPCore (x.re x.im y.re y.im)
:precision binary64
(if (<= y.im -5.5e-18)
(/ (+ x.im (/ x.re (/ y.im y.re))) y.im)
(if (<= y.im 8.4e-150)
(/ (+ x.re (/ (* x.im y.im) y.re)) y.re)
(/ (+ x.im (* y.re (/ x.re y.im))) 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-18) {
tmp = (x_46_im + (x_46_re / (y_46_im / y_46_re))) / y_46_im;
} else if (y_46_im <= 8.4e-150) {
tmp = (x_46_re + ((x_46_im * y_46_im) / y_46_re)) / y_46_re;
} else {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / 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 <= (-5.5d-18)) then
tmp = (x_46im + (x_46re / (y_46im / y_46re))) / y_46im
else if (y_46im <= 8.4d-150) then
tmp = (x_46re + ((x_46im * y_46im) / y_46re)) / y_46re
else
tmp = (x_46im + (y_46re * (x_46re / y_46im))) / 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 <= -5.5e-18) {
tmp = (x_46_im + (x_46_re / (y_46_im / y_46_re))) / y_46_im;
} else if (y_46_im <= 8.4e-150) {
tmp = (x_46_re + ((x_46_im * y_46_im) / y_46_re)) / y_46_re;
} else {
tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / 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 <= -5.5e-18: tmp = (x_46_im + (x_46_re / (y_46_im / y_46_re))) / y_46_im elif y_46_im <= 8.4e-150: tmp = (x_46_re + ((x_46_im * y_46_im) / y_46_re)) / y_46_re else: tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / 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-18) tmp = Float64(Float64(x_46_im + Float64(x_46_re / Float64(y_46_im / y_46_re))) / y_46_im); elseif (y_46_im <= 8.4e-150) tmp = Float64(Float64(x_46_re + Float64(Float64(x_46_im * y_46_im) / y_46_re)) / y_46_re); else tmp = Float64(Float64(x_46_im + Float64(y_46_re * Float64(x_46_re / y_46_im))) / 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 <= -5.5e-18) tmp = (x_46_im + (x_46_re / (y_46_im / y_46_re))) / y_46_im; elseif (y_46_im <= 8.4e-150) tmp = (x_46_re + ((x_46_im * y_46_im) / y_46_re)) / y_46_re; else tmp = (x_46_im + (y_46_re * (x_46_re / y_46_im))) / 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, -5.5e-18], N[(N[(x$46$im + N[(x$46$re / N[(y$46$im / y$46$re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision], If[LessEqual[y$46$im, 8.4e-150], N[(N[(x$46$re + N[(N[(x$46$im * y$46$im), $MachinePrecision] / y$46$re), $MachinePrecision]), $MachinePrecision] / y$46$re), $MachinePrecision], N[(N[(x$46$im + N[(y$46$re * N[(x$46$re / y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y$46$im), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -5.5 \cdot 10^{-18}:\\
\;\;\;\;\frac{x.im + \frac{x.re}{\frac{y.im}{y.re}}}{y.im}\\
\mathbf{elif}\;y.im \leq 8.4 \cdot 10^{-150}:\\
\;\;\;\;\frac{x.re + \frac{x.im \cdot y.im}{y.re}}{y.re}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.im + y.re \cdot \frac{x.re}{y.im}}{y.im}\\
\end{array}
\end{array}
if y.im < -5.5e-18Initial program 49.1%
fma-define49.1%
fma-define49.1%
Simplified49.1%
Taylor expanded in y.im around inf 71.3%
associate-/l*74.4%
Simplified74.4%
clear-num74.4%
un-div-inv74.5%
Applied egg-rr74.5%
if -5.5e-18 < y.im < 8.4000000000000004e-150Initial program 70.5%
fma-define70.5%
fma-define70.5%
Simplified70.5%
Taylor expanded in y.re around inf 88.0%
*-commutative88.0%
Simplified88.0%
if 8.4000000000000004e-150 < y.im Initial program 49.1%
fma-define49.1%
fma-define49.1%
Simplified49.1%
Taylor expanded in y.im around inf 76.1%
*-commutative76.1%
*-un-lft-identity76.1%
times-frac77.4%
Applied egg-rr77.4%
Final simplification81.0%
(FPCore (x.re x.im y.re y.im) :precision binary64 (if (or (<= y.im -3e-18) (not (<= y.im 3.1e-156))) (/ x.im y.im) (/ x.re y.re)))
double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
double tmp;
if ((y_46_im <= -3e-18) || !(y_46_im <= 3.1e-156)) {
tmp = x_46_im / y_46_im;
} else {
tmp = x_46_re / y_46_re;
}
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 <= (-3d-18)) .or. (.not. (y_46im <= 3.1d-156))) then
tmp = x_46im / y_46im
else
tmp = x_46re / y_46re
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 <= -3e-18) || !(y_46_im <= 3.1e-156)) {
tmp = x_46_im / y_46_im;
} else {
tmp = x_46_re / y_46_re;
}
return tmp;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): tmp = 0 if (y_46_im <= -3e-18) or not (y_46_im <= 3.1e-156): tmp = x_46_im / y_46_im else: tmp = x_46_re / y_46_re return tmp
function code(x_46_re, x_46_im, y_46_re, y_46_im) tmp = 0.0 if ((y_46_im <= -3e-18) || !(y_46_im <= 3.1e-156)) tmp = Float64(x_46_im / y_46_im); else tmp = Float64(x_46_re / y_46_re); 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 <= -3e-18) || ~((y_46_im <= 3.1e-156))) tmp = x_46_im / y_46_im; else tmp = x_46_re / y_46_re; end tmp_2 = tmp; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$im, -3e-18], N[Not[LessEqual[y$46$im, 3.1e-156]], $MachinePrecision]], N[(x$46$im / y$46$im), $MachinePrecision], N[(x$46$re / y$46$re), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y.im \leq -3 \cdot 10^{-18} \lor \neg \left(y.im \leq 3.1 \cdot 10^{-156}\right):\\
\;\;\;\;\frac{x.im}{y.im}\\
\mathbf{else}:\\
\;\;\;\;\frac{x.re}{y.re}\\
\end{array}
\end{array}
if y.im < -2.99999999999999983e-18 or 3.0999999999999998e-156 < y.im Initial program 49.7%
fma-define49.7%
fma-define49.7%
Simplified49.7%
Taylor expanded in y.re around 0 64.9%
if -2.99999999999999983e-18 < y.im < 3.0999999999999998e-156Initial program 69.9%
fma-define69.9%
fma-define69.9%
Simplified69.9%
Taylor expanded in y.re around inf 69.1%
Final simplification66.5%
(FPCore (x.re x.im y.re y.im) :precision binary64 (/ x.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_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_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_im;
}
def code(x_46_re, x_46_im, y_46_re, y_46_im): return x_46_im / y_46_im
function code(x_46_re, x_46_im, y_46_re, y_46_im) return Float64(x_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_im; end
code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(x$46$im / y$46$im), $MachinePrecision]
\begin{array}{l}
\\
\frac{x.im}{y.im}
\end{array}
Initial program 57.8%
fma-define57.8%
fma-define57.8%
Simplified57.8%
Taylor expanded in y.re around 0 43.8%
herbie shell --seed 2024141
(FPCore (x.re x.im y.re y.im)
:name "_divideComplex, real part"
:precision binary64
(/ (+ (* x.re y.re) (* x.im y.im)) (+ (* y.re y.re) (* y.im y.im))))