
(FPCore (re im) :precision binary64 (* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))
double code(double re, double im) {
return 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) + re)));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = 0.5d0 * sqrt((2.0d0 * (sqrt(((re * re) + (im * im))) + re)))
end function
public static double code(double re, double im) {
return 0.5 * Math.sqrt((2.0 * (Math.sqrt(((re * re) + (im * im))) + re)));
}
def code(re, im): return 0.5 * math.sqrt((2.0 * (math.sqrt(((re * re) + (im * im))) + re)))
function code(re, im) return Float64(0.5 * sqrt(Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) + re)))) end
function tmp = code(re, im) tmp = 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) + re))); end
code[re_, im_] := N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} + re\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im) :precision binary64 (* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))
double code(double re, double im) {
return 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) + re)));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = 0.5d0 * sqrt((2.0d0 * (sqrt(((re * re) + (im * im))) + re)))
end function
public static double code(double re, double im) {
return 0.5 * Math.sqrt((2.0 * (Math.sqrt(((re * re) + (im * im))) + re)));
}
def code(re, im): return 0.5 * math.sqrt((2.0 * (math.sqrt(((re * re) + (im * im))) + re)))
function code(re, im) return Float64(0.5 * sqrt(Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) + re)))) end
function tmp = code(re, im) tmp = 0.5 * sqrt((2.0 * (sqrt(((re * re) + (im * im))) + re))); end
code[re_, im_] := N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.5 \cdot \sqrt{2 \cdot \left(\sqrt{re \cdot re + im \cdot im} + re\right)}
\end{array}
im_m = (fabs.f64 im)
(FPCore (re im_m)
:precision binary64
(let* ((t_0 (sqrt (* 0.5 (+ re (hypot re im_m)))))
(t_1 (* (/ im_m (sqrt (* re -2.0))) (sqrt 0.5))))
(if (<= re -1.92e+211)
t_1
(if (<= re -7.2e+185)
t_0
(if (<= re -3.3e-22)
(* (sqrt 0.5) (* im_m (sqrt (/ -0.5 re))))
(if (or (<= re -7.6e-135) (not (<= re -3.05e-152))) t_0 t_1))))))im_m = fabs(im);
double code(double re, double im_m) {
double t_0 = sqrt((0.5 * (re + hypot(re, im_m))));
double t_1 = (im_m / sqrt((re * -2.0))) * sqrt(0.5);
double tmp;
if (re <= -1.92e+211) {
tmp = t_1;
} else if (re <= -7.2e+185) {
tmp = t_0;
} else if (re <= -3.3e-22) {
tmp = sqrt(0.5) * (im_m * sqrt((-0.5 / re)));
} else if ((re <= -7.6e-135) || !(re <= -3.05e-152)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double t_0 = Math.sqrt((0.5 * (re + Math.hypot(re, im_m))));
double t_1 = (im_m / Math.sqrt((re * -2.0))) * Math.sqrt(0.5);
double tmp;
if (re <= -1.92e+211) {
tmp = t_1;
} else if (re <= -7.2e+185) {
tmp = t_0;
} else if (re <= -3.3e-22) {
tmp = Math.sqrt(0.5) * (im_m * Math.sqrt((-0.5 / re)));
} else if ((re <= -7.6e-135) || !(re <= -3.05e-152)) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): t_0 = math.sqrt((0.5 * (re + math.hypot(re, im_m)))) t_1 = (im_m / math.sqrt((re * -2.0))) * math.sqrt(0.5) tmp = 0 if re <= -1.92e+211: tmp = t_1 elif re <= -7.2e+185: tmp = t_0 elif re <= -3.3e-22: tmp = math.sqrt(0.5) * (im_m * math.sqrt((-0.5 / re))) elif (re <= -7.6e-135) or not (re <= -3.05e-152): tmp = t_0 else: tmp = t_1 return tmp
im_m = abs(im) function code(re, im_m) t_0 = sqrt(Float64(0.5 * Float64(re + hypot(re, im_m)))) t_1 = Float64(Float64(im_m / sqrt(Float64(re * -2.0))) * sqrt(0.5)) tmp = 0.0 if (re <= -1.92e+211) tmp = t_1; elseif (re <= -7.2e+185) tmp = t_0; elseif (re <= -3.3e-22) tmp = Float64(sqrt(0.5) * Float64(im_m * sqrt(Float64(-0.5 / re)))); elseif ((re <= -7.6e-135) || !(re <= -3.05e-152)) tmp = t_0; else tmp = t_1; end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) t_0 = sqrt((0.5 * (re + hypot(re, im_m)))); t_1 = (im_m / sqrt((re * -2.0))) * sqrt(0.5); tmp = 0.0; if (re <= -1.92e+211) tmp = t_1; elseif (re <= -7.2e+185) tmp = t_0; elseif (re <= -3.3e-22) tmp = sqrt(0.5) * (im_m * sqrt((-0.5 / re))); elseif ((re <= -7.6e-135) || ~((re <= -3.05e-152))) tmp = t_0; else tmp = t_1; end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision]
code[re_, im$95$m_] := Block[{t$95$0 = N[Sqrt[N[(0.5 * N[(re + N[Sqrt[re ^ 2 + im$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[(im$95$m / N[Sqrt[N[(re * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -1.92e+211], t$95$1, If[LessEqual[re, -7.2e+185], t$95$0, If[LessEqual[re, -3.3e-22], N[(N[Sqrt[0.5], $MachinePrecision] * N[(im$95$m * N[Sqrt[N[(-0.5 / re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[re, -7.6e-135], N[Not[LessEqual[re, -3.05e-152]], $MachinePrecision]], t$95$0, t$95$1]]]]]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
t_0 := \sqrt{0.5 \cdot \left(re + \mathsf{hypot}\left(re, im\_m\right)\right)}\\
t_1 := \frac{im\_m}{\sqrt{re \cdot -2}} \cdot \sqrt{0.5}\\
\mathbf{if}\;re \leq -1.92 \cdot 10^{+211}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;re \leq -7.2 \cdot 10^{+185}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;re \leq -3.3 \cdot 10^{-22}:\\
\;\;\;\;\sqrt{0.5} \cdot \left(im\_m \cdot \sqrt{\frac{-0.5}{re}}\right)\\
\mathbf{elif}\;re \leq -7.6 \cdot 10^{-135} \lor \neg \left(re \leq -3.05 \cdot 10^{-152}\right):\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if re < -1.91999999999999991e211 or -7.6000000000000005e-135 < re < -3.04999999999999991e-152Initial program 5.8%
sqr-neg5.8%
+-commutative5.8%
sqr-neg5.8%
+-commutative5.8%
distribute-rgt-in5.8%
cancel-sign-sub5.8%
distribute-rgt-out--5.8%
sub-neg5.8%
remove-double-neg5.8%
+-commutative5.8%
hypot-define26.5%
Simplified26.5%
*-commutative26.5%
hypot-define5.8%
+-commutative5.8%
*-commutative5.8%
add-sqr-sqrt5.7%
sqrt-unprod5.8%
*-commutative5.8%
*-commutative5.8%
swap-sqr5.8%
Applied egg-rr26.5%
*-commutative26.5%
associate-*r*26.5%
metadata-eval26.5%
Simplified26.5%
*-commutative26.5%
sqrt-prod26.4%
Applied egg-rr26.4%
Taylor expanded in re around -inf 43.7%
*-commutative42.0%
associate-*l/41.8%
Simplified43.5%
clear-num43.4%
sqrt-div43.5%
metadata-eval43.5%
*-un-lft-identity43.5%
*-commutative43.5%
times-frac43.6%
metadata-eval43.6%
associate-*r/43.7%
sqrt-div56.4%
*-commutative56.4%
sqrt-pow146.0%
metadata-eval46.0%
pow146.0%
Applied egg-rr46.0%
associate-/r/46.0%
associate-*l/46.1%
*-lft-identity46.1%
Simplified46.1%
if -1.91999999999999991e211 < re < -7.20000000000000058e185 or -3.3000000000000001e-22 < re < -7.6000000000000005e-135 or -3.04999999999999991e-152 < re Initial program 50.8%
sqr-neg50.8%
+-commutative50.8%
sqr-neg50.8%
+-commutative50.8%
distribute-rgt-in50.8%
cancel-sign-sub50.8%
distribute-rgt-out--50.8%
sub-neg50.8%
remove-double-neg50.8%
+-commutative50.8%
hypot-define93.9%
Simplified93.9%
*-commutative93.9%
hypot-define50.8%
+-commutative50.8%
*-commutative50.8%
add-sqr-sqrt50.4%
sqrt-unprod50.8%
*-commutative50.8%
*-commutative50.8%
swap-sqr50.8%
Applied egg-rr93.9%
*-commutative93.9%
associate-*r*93.9%
metadata-eval93.9%
Simplified93.9%
if -7.20000000000000058e185 < re < -3.3000000000000001e-22Initial program 19.0%
sqr-neg19.0%
+-commutative19.0%
sqr-neg19.0%
+-commutative19.0%
distribute-rgt-in19.0%
cancel-sign-sub19.0%
distribute-rgt-out--19.0%
sub-neg19.0%
remove-double-neg19.0%
+-commutative19.0%
hypot-define34.3%
Simplified34.3%
*-commutative34.3%
hypot-define19.0%
+-commutative19.0%
*-commutative19.0%
add-sqr-sqrt19.0%
sqrt-unprod19.0%
*-commutative19.0%
*-commutative19.0%
swap-sqr19.0%
Applied egg-rr34.3%
*-commutative34.3%
associate-*r*34.3%
metadata-eval34.3%
Simplified34.3%
*-commutative34.3%
sqrt-prod34.1%
Applied egg-rr34.1%
Taylor expanded in re around -inf 53.6%
*-commutative51.2%
associate-*l/51.2%
Simplified53.6%
pow1/253.6%
associate-/l*53.6%
unpow-prod-down61.6%
pow1/261.6%
sqrt-pow149.3%
metadata-eval49.3%
pow149.3%
Applied egg-rr49.3%
unpow1/249.3%
Simplified49.3%
Final simplification79.1%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (<= (sqrt (* 2.0 (+ re (sqrt (+ (* re re) (* im_m im_m)))))) 0.0) (* im_m (/ (* 0.5 (sqrt 2.0)) (sqrt (* re -2.0)))) (sqrt (* 0.5 (+ re (hypot re im_m))))))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if (sqrt((2.0 * (re + sqrt(((re * re) + (im_m * im_m)))))) <= 0.0) {
tmp = im_m * ((0.5 * sqrt(2.0)) / sqrt((re * -2.0)));
} else {
tmp = sqrt((0.5 * (re + hypot(re, im_m))));
}
return tmp;
}
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if (Math.sqrt((2.0 * (re + Math.sqrt(((re * re) + (im_m * im_m)))))) <= 0.0) {
tmp = im_m * ((0.5 * Math.sqrt(2.0)) / Math.sqrt((re * -2.0)));
} else {
tmp = Math.sqrt((0.5 * (re + Math.hypot(re, im_m))));
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if math.sqrt((2.0 * (re + math.sqrt(((re * re) + (im_m * im_m)))))) <= 0.0: tmp = im_m * ((0.5 * math.sqrt(2.0)) / math.sqrt((re * -2.0))) else: tmp = math.sqrt((0.5 * (re + math.hypot(re, im_m)))) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if (sqrt(Float64(2.0 * Float64(re + sqrt(Float64(Float64(re * re) + Float64(im_m * im_m)))))) <= 0.0) tmp = Float64(im_m * Float64(Float64(0.5 * sqrt(2.0)) / sqrt(Float64(re * -2.0)))); else tmp = sqrt(Float64(0.5 * Float64(re + hypot(re, im_m)))); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if (sqrt((2.0 * (re + sqrt(((re * re) + (im_m * im_m)))))) <= 0.0) tmp = im_m * ((0.5 * sqrt(2.0)) / sqrt((re * -2.0))); else tmp = sqrt((0.5 * (re + hypot(re, im_m)))); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[LessEqual[N[Sqrt[N[(2.0 * N[(re + N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im$95$m * im$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[(im$95$m * N[(N[(0.5 * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Sqrt[N[(re * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[(0.5 * N[(re + N[Sqrt[re ^ 2 + im$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;\sqrt{2 \cdot \left(re + \sqrt{re \cdot re + im\_m \cdot im\_m}\right)} \leq 0:\\
\;\;\;\;im\_m \cdot \frac{0.5 \cdot \sqrt{2}}{\sqrt{re \cdot -2}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{0.5 \cdot \left(re + \mathsf{hypot}\left(re, im\_m\right)\right)}\\
\end{array}
\end{array}
if (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) < 0.0Initial program 11.9%
sqr-neg11.9%
+-commutative11.9%
sqr-neg11.9%
+-commutative11.9%
distribute-rgt-in11.9%
cancel-sign-sub11.9%
distribute-rgt-out--11.9%
sub-neg11.9%
remove-double-neg11.9%
+-commutative11.9%
hypot-define11.9%
Simplified11.9%
hypot-define11.9%
add-exp-log11.9%
hypot-define11.9%
Applied egg-rr11.9%
Taylor expanded in re around -inf 49.1%
*-commutative49.1%
associate-*l/48.9%
Simplified48.9%
rem-exp-log51.9%
clear-num51.3%
un-div-inv51.3%
*-un-lft-identity51.3%
pow251.3%
*-commutative51.3%
times-frac51.4%
metadata-eval51.4%
pow251.4%
Applied egg-rr51.4%
sqrt-div51.2%
associate-*r/51.2%
associate-*r/51.2%
sqrt-div59.6%
*-commutative59.6%
sqrt-pow157.1%
metadata-eval57.1%
pow157.1%
Applied egg-rr57.1%
associate-/r/57.4%
Simplified57.4%
if 0.0 < (sqrt.f64 (*.f64 #s(literal 2 binary64) (+.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re))) Initial program 44.3%
sqr-neg44.3%
+-commutative44.3%
sqr-neg44.3%
+-commutative44.3%
distribute-rgt-in44.3%
cancel-sign-sub44.3%
distribute-rgt-out--44.3%
sub-neg44.3%
remove-double-neg44.3%
+-commutative44.3%
hypot-define86.8%
Simplified86.8%
*-commutative86.8%
hypot-define44.3%
+-commutative44.3%
*-commutative44.3%
add-sqr-sqrt44.0%
sqrt-unprod44.3%
*-commutative44.3%
*-commutative44.3%
swap-sqr44.3%
Applied egg-rr86.8%
*-commutative86.8%
associate-*r*86.8%
metadata-eval86.8%
Simplified86.8%
Final simplification81.6%
im_m = (fabs.f64 im)
(FPCore (re im_m)
:precision binary64
(if (or (<= re -1.92e+211)
(and (not (<= re -7.2e+185))
(or (<= re -3.3e-22)
(and (not (<= re -5.6e-132)) (<= re -2.2e-151)))))
(* im_m (* (sqrt 0.5) (sqrt (/ -0.5 re))))
(sqrt (* 0.5 (+ re (hypot re im_m))))))im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if ((re <= -1.92e+211) || (!(re <= -7.2e+185) && ((re <= -3.3e-22) || (!(re <= -5.6e-132) && (re <= -2.2e-151))))) {
tmp = im_m * (sqrt(0.5) * sqrt((-0.5 / re)));
} else {
tmp = sqrt((0.5 * (re + hypot(re, im_m))));
}
return tmp;
}
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if ((re <= -1.92e+211) || (!(re <= -7.2e+185) && ((re <= -3.3e-22) || (!(re <= -5.6e-132) && (re <= -2.2e-151))))) {
tmp = im_m * (Math.sqrt(0.5) * Math.sqrt((-0.5 / re)));
} else {
tmp = Math.sqrt((0.5 * (re + Math.hypot(re, im_m))));
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if (re <= -1.92e+211) or (not (re <= -7.2e+185) and ((re <= -3.3e-22) or (not (re <= -5.6e-132) and (re <= -2.2e-151)))): tmp = im_m * (math.sqrt(0.5) * math.sqrt((-0.5 / re))) else: tmp = math.sqrt((0.5 * (re + math.hypot(re, im_m)))) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if ((re <= -1.92e+211) || (!(re <= -7.2e+185) && ((re <= -3.3e-22) || (!(re <= -5.6e-132) && (re <= -2.2e-151))))) tmp = Float64(im_m * Float64(sqrt(0.5) * sqrt(Float64(-0.5 / re)))); else tmp = sqrt(Float64(0.5 * Float64(re + hypot(re, im_m)))); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if ((re <= -1.92e+211) || (~((re <= -7.2e+185)) && ((re <= -3.3e-22) || (~((re <= -5.6e-132)) && (re <= -2.2e-151))))) tmp = im_m * (sqrt(0.5) * sqrt((-0.5 / re))); else tmp = sqrt((0.5 * (re + hypot(re, im_m)))); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[Or[LessEqual[re, -1.92e+211], And[N[Not[LessEqual[re, -7.2e+185]], $MachinePrecision], Or[LessEqual[re, -3.3e-22], And[N[Not[LessEqual[re, -5.6e-132]], $MachinePrecision], LessEqual[re, -2.2e-151]]]]], N[(im$95$m * N[(N[Sqrt[0.5], $MachinePrecision] * N[Sqrt[N[(-0.5 / re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[Sqrt[N[(0.5 * N[(re + N[Sqrt[re ^ 2 + im$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.92 \cdot 10^{+211} \lor \neg \left(re \leq -7.2 \cdot 10^{+185}\right) \land \left(re \leq -3.3 \cdot 10^{-22} \lor \neg \left(re \leq -5.6 \cdot 10^{-132}\right) \land re \leq -2.2 \cdot 10^{-151}\right):\\
\;\;\;\;im\_m \cdot \left(\sqrt{0.5} \cdot \sqrt{\frac{-0.5}{re}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{0.5 \cdot \left(re + \mathsf{hypot}\left(re, im\_m\right)\right)}\\
\end{array}
\end{array}
if re < -1.91999999999999991e211 or -7.20000000000000058e185 < re < -3.3000000000000001e-22 or -5.60000000000000005e-132 < re < -2.1999999999999999e-151Initial program 12.9%
sqr-neg12.9%
+-commutative12.9%
sqr-neg12.9%
+-commutative12.9%
distribute-rgt-in12.9%
cancel-sign-sub12.9%
distribute-rgt-out--12.9%
sub-neg12.9%
remove-double-neg12.9%
+-commutative12.9%
hypot-define30.7%
Simplified30.7%
*-commutative30.7%
hypot-define12.9%
+-commutative12.9%
*-commutative12.9%
add-sqr-sqrt12.9%
sqrt-unprod12.9%
*-commutative12.9%
*-commutative12.9%
swap-sqr12.9%
Applied egg-rr30.7%
*-commutative30.7%
associate-*r*30.7%
metadata-eval30.7%
Simplified30.7%
*-commutative30.7%
sqrt-prod30.6%
Applied egg-rr30.6%
Taylor expanded in re around -inf 49.0%
*-commutative46.9%
associate-*l/46.8%
Simplified48.9%
pow148.9%
associate-/l*49.0%
sqrt-prod59.2%
sqrt-pow147.7%
metadata-eval47.7%
pow147.7%
Applied egg-rr47.7%
unpow147.7%
unpow1/247.7%
associate-*l*47.7%
unpow1/247.7%
Simplified47.7%
if -1.91999999999999991e211 < re < -7.20000000000000058e185 or -3.3000000000000001e-22 < re < -5.60000000000000005e-132 or -2.1999999999999999e-151 < re Initial program 50.8%
sqr-neg50.8%
+-commutative50.8%
sqr-neg50.8%
+-commutative50.8%
distribute-rgt-in50.8%
cancel-sign-sub50.8%
distribute-rgt-out--50.8%
sub-neg50.8%
remove-double-neg50.8%
+-commutative50.8%
hypot-define93.9%
Simplified93.9%
*-commutative93.9%
hypot-define50.8%
+-commutative50.8%
*-commutative50.8%
add-sqr-sqrt50.4%
sqrt-unprod50.8%
*-commutative50.8%
*-commutative50.8%
swap-sqr50.8%
Applied egg-rr93.9%
*-commutative93.9%
associate-*r*93.9%
metadata-eval93.9%
Simplified93.9%
Final simplification79.1%
im_m = (fabs.f64 im)
(FPCore (re im_m)
:precision binary64
(let* ((t_0 (sqrt (* 0.5 (+ re (hypot re im_m)))))
(t_1 (sqrt (/ -0.5 re)))
(t_2 (* im_m (* (sqrt 0.5) t_1))))
(if (<= re -1.92e+211)
t_2
(if (<= re -7.2e+185)
t_0
(if (<= re -1.65e-22)
(* (sqrt 0.5) (* im_m t_1))
(if (or (<= re -2.2e-134) (not (<= re -2.2e-151))) t_0 t_2))))))im_m = fabs(im);
double code(double re, double im_m) {
double t_0 = sqrt((0.5 * (re + hypot(re, im_m))));
double t_1 = sqrt((-0.5 / re));
double t_2 = im_m * (sqrt(0.5) * t_1);
double tmp;
if (re <= -1.92e+211) {
tmp = t_2;
} else if (re <= -7.2e+185) {
tmp = t_0;
} else if (re <= -1.65e-22) {
tmp = sqrt(0.5) * (im_m * t_1);
} else if ((re <= -2.2e-134) || !(re <= -2.2e-151)) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double t_0 = Math.sqrt((0.5 * (re + Math.hypot(re, im_m))));
double t_1 = Math.sqrt((-0.5 / re));
double t_2 = im_m * (Math.sqrt(0.5) * t_1);
double tmp;
if (re <= -1.92e+211) {
tmp = t_2;
} else if (re <= -7.2e+185) {
tmp = t_0;
} else if (re <= -1.65e-22) {
tmp = Math.sqrt(0.5) * (im_m * t_1);
} else if ((re <= -2.2e-134) || !(re <= -2.2e-151)) {
tmp = t_0;
} else {
tmp = t_2;
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): t_0 = math.sqrt((0.5 * (re + math.hypot(re, im_m)))) t_1 = math.sqrt((-0.5 / re)) t_2 = im_m * (math.sqrt(0.5) * t_1) tmp = 0 if re <= -1.92e+211: tmp = t_2 elif re <= -7.2e+185: tmp = t_0 elif re <= -1.65e-22: tmp = math.sqrt(0.5) * (im_m * t_1) elif (re <= -2.2e-134) or not (re <= -2.2e-151): tmp = t_0 else: tmp = t_2 return tmp
im_m = abs(im) function code(re, im_m) t_0 = sqrt(Float64(0.5 * Float64(re + hypot(re, im_m)))) t_1 = sqrt(Float64(-0.5 / re)) t_2 = Float64(im_m * Float64(sqrt(0.5) * t_1)) tmp = 0.0 if (re <= -1.92e+211) tmp = t_2; elseif (re <= -7.2e+185) tmp = t_0; elseif (re <= -1.65e-22) tmp = Float64(sqrt(0.5) * Float64(im_m * t_1)); elseif ((re <= -2.2e-134) || !(re <= -2.2e-151)) tmp = t_0; else tmp = t_2; end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) t_0 = sqrt((0.5 * (re + hypot(re, im_m)))); t_1 = sqrt((-0.5 / re)); t_2 = im_m * (sqrt(0.5) * t_1); tmp = 0.0; if (re <= -1.92e+211) tmp = t_2; elseif (re <= -7.2e+185) tmp = t_0; elseif (re <= -1.65e-22) tmp = sqrt(0.5) * (im_m * t_1); elseif ((re <= -2.2e-134) || ~((re <= -2.2e-151))) tmp = t_0; else tmp = t_2; end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision]
code[re_, im$95$m_] := Block[{t$95$0 = N[Sqrt[N[(0.5 * N[(re + N[Sqrt[re ^ 2 + im$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(-0.5 / re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(im$95$m * N[(N[Sqrt[0.5], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[re, -1.92e+211], t$95$2, If[LessEqual[re, -7.2e+185], t$95$0, If[LessEqual[re, -1.65e-22], N[(N[Sqrt[0.5], $MachinePrecision] * N[(im$95$m * t$95$1), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[re, -2.2e-134], N[Not[LessEqual[re, -2.2e-151]], $MachinePrecision]], t$95$0, t$95$2]]]]]]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
t_0 := \sqrt{0.5 \cdot \left(re + \mathsf{hypot}\left(re, im\_m\right)\right)}\\
t_1 := \sqrt{\frac{-0.5}{re}}\\
t_2 := im\_m \cdot \left(\sqrt{0.5} \cdot t\_1\right)\\
\mathbf{if}\;re \leq -1.92 \cdot 10^{+211}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;re \leq -7.2 \cdot 10^{+185}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;re \leq -1.65 \cdot 10^{-22}:\\
\;\;\;\;\sqrt{0.5} \cdot \left(im\_m \cdot t\_1\right)\\
\mathbf{elif}\;re \leq -2.2 \cdot 10^{-134} \lor \neg \left(re \leq -2.2 \cdot 10^{-151}\right):\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if re < -1.91999999999999991e211 or -2.2e-134 < re < -2.1999999999999999e-151Initial program 5.8%
sqr-neg5.8%
+-commutative5.8%
sqr-neg5.8%
+-commutative5.8%
distribute-rgt-in5.8%
cancel-sign-sub5.8%
distribute-rgt-out--5.8%
sub-neg5.8%
remove-double-neg5.8%
+-commutative5.8%
hypot-define26.5%
Simplified26.5%
*-commutative26.5%
hypot-define5.8%
+-commutative5.8%
*-commutative5.8%
add-sqr-sqrt5.7%
sqrt-unprod5.8%
*-commutative5.8%
*-commutative5.8%
swap-sqr5.8%
Applied egg-rr26.5%
*-commutative26.5%
associate-*r*26.5%
metadata-eval26.5%
Simplified26.5%
*-commutative26.5%
sqrt-prod26.4%
Applied egg-rr26.4%
Taylor expanded in re around -inf 43.7%
*-commutative42.0%
associate-*l/41.8%
Simplified43.5%
pow143.5%
associate-/l*43.6%
sqrt-prod56.4%
sqrt-pow145.9%
metadata-eval45.9%
pow145.9%
Applied egg-rr45.9%
unpow145.9%
unpow1/245.9%
associate-*l*46.0%
unpow1/246.0%
Simplified46.0%
if -1.91999999999999991e211 < re < -7.20000000000000058e185 or -1.65e-22 < re < -2.2e-134 or -2.1999999999999999e-151 < re Initial program 50.8%
sqr-neg50.8%
+-commutative50.8%
sqr-neg50.8%
+-commutative50.8%
distribute-rgt-in50.8%
cancel-sign-sub50.8%
distribute-rgt-out--50.8%
sub-neg50.8%
remove-double-neg50.8%
+-commutative50.8%
hypot-define93.9%
Simplified93.9%
*-commutative93.9%
hypot-define50.8%
+-commutative50.8%
*-commutative50.8%
add-sqr-sqrt50.4%
sqrt-unprod50.8%
*-commutative50.8%
*-commutative50.8%
swap-sqr50.8%
Applied egg-rr93.9%
*-commutative93.9%
associate-*r*93.9%
metadata-eval93.9%
Simplified93.9%
if -7.20000000000000058e185 < re < -1.65e-22Initial program 19.0%
sqr-neg19.0%
+-commutative19.0%
sqr-neg19.0%
+-commutative19.0%
distribute-rgt-in19.0%
cancel-sign-sub19.0%
distribute-rgt-out--19.0%
sub-neg19.0%
remove-double-neg19.0%
+-commutative19.0%
hypot-define34.3%
Simplified34.3%
*-commutative34.3%
hypot-define19.0%
+-commutative19.0%
*-commutative19.0%
add-sqr-sqrt19.0%
sqrt-unprod19.0%
*-commutative19.0%
*-commutative19.0%
swap-sqr19.0%
Applied egg-rr34.3%
*-commutative34.3%
associate-*r*34.3%
metadata-eval34.3%
Simplified34.3%
*-commutative34.3%
sqrt-prod34.1%
Applied egg-rr34.1%
Taylor expanded in re around -inf 53.6%
*-commutative51.2%
associate-*l/51.2%
Simplified53.6%
pow1/253.6%
associate-/l*53.6%
unpow-prod-down61.6%
pow1/261.6%
sqrt-pow149.3%
metadata-eval49.3%
pow149.3%
Applied egg-rr49.3%
unpow1/249.3%
Simplified49.3%
Final simplification79.1%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (or (<= re -1.32e+216) (and (not (<= re -7.2e+185)) (<= re -4.8e+43))) (* 0.5 (sqrt (* (/ im_m -1.0) (/ im_m re)))) (sqrt (* 0.5 (+ re (hypot re im_m))))))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if ((re <= -1.32e+216) || (!(re <= -7.2e+185) && (re <= -4.8e+43))) {
tmp = 0.5 * sqrt(((im_m / -1.0) * (im_m / re)));
} else {
tmp = sqrt((0.5 * (re + hypot(re, im_m))));
}
return tmp;
}
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if ((re <= -1.32e+216) || (!(re <= -7.2e+185) && (re <= -4.8e+43))) {
tmp = 0.5 * Math.sqrt(((im_m / -1.0) * (im_m / re)));
} else {
tmp = Math.sqrt((0.5 * (re + Math.hypot(re, im_m))));
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if (re <= -1.32e+216) or (not (re <= -7.2e+185) and (re <= -4.8e+43)): tmp = 0.5 * math.sqrt(((im_m / -1.0) * (im_m / re))) else: tmp = math.sqrt((0.5 * (re + math.hypot(re, im_m)))) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if ((re <= -1.32e+216) || (!(re <= -7.2e+185) && (re <= -4.8e+43))) tmp = Float64(0.5 * sqrt(Float64(Float64(im_m / -1.0) * Float64(im_m / re)))); else tmp = sqrt(Float64(0.5 * Float64(re + hypot(re, im_m)))); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if ((re <= -1.32e+216) || (~((re <= -7.2e+185)) && (re <= -4.8e+43))) tmp = 0.5 * sqrt(((im_m / -1.0) * (im_m / re))); else tmp = sqrt((0.5 * (re + hypot(re, im_m)))); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[Or[LessEqual[re, -1.32e+216], And[N[Not[LessEqual[re, -7.2e+185]], $MachinePrecision], LessEqual[re, -4.8e+43]]], N[(0.5 * N[Sqrt[N[(N[(im$95$m / -1.0), $MachinePrecision] * N[(im$95$m / re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Sqrt[N[(0.5 * N[(re + N[Sqrt[re ^ 2 + im$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.32 \cdot 10^{+216} \lor \neg \left(re \leq -7.2 \cdot 10^{+185}\right) \land re \leq -4.8 \cdot 10^{+43}:\\
\;\;\;\;0.5 \cdot \sqrt{\frac{im\_m}{-1} \cdot \frac{im\_m}{re}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{0.5 \cdot \left(re + \mathsf{hypot}\left(re, im\_m\right)\right)}\\
\end{array}
\end{array}
if re < -1.3199999999999999e216 or -7.20000000000000058e185 < re < -4.80000000000000046e43Initial program 9.9%
sqr-neg9.9%
+-commutative9.9%
sqr-neg9.9%
+-commutative9.9%
distribute-rgt-in9.9%
cancel-sign-sub9.9%
distribute-rgt-out--9.9%
sub-neg9.9%
remove-double-neg9.9%
+-commutative9.9%
hypot-define30.1%
Simplified30.1%
Taylor expanded in re around -inf 59.3%
mul-1-neg59.3%
distribute-neg-frac259.3%
Simplified59.3%
unpow259.3%
neg-mul-159.3%
times-frac68.5%
Applied egg-rr68.5%
if -1.3199999999999999e216 < re < -7.20000000000000058e185 or -4.80000000000000046e43 < re Initial program 47.0%
sqr-neg47.0%
+-commutative47.0%
sqr-neg47.0%
+-commutative47.0%
distribute-rgt-in47.0%
cancel-sign-sub47.0%
distribute-rgt-out--47.0%
sub-neg47.0%
remove-double-neg47.0%
+-commutative47.0%
hypot-define86.4%
Simplified86.4%
*-commutative86.4%
hypot-define47.0%
+-commutative47.0%
*-commutative47.0%
add-sqr-sqrt46.7%
sqrt-unprod47.0%
*-commutative47.0%
*-commutative47.0%
swap-sqr47.0%
Applied egg-rr86.4%
*-commutative86.4%
associate-*r*86.4%
metadata-eval86.4%
Simplified86.4%
Final simplification82.3%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (<= re -1.85e-22) (* 0.5 (sqrt (* (/ im_m -1.0) (/ im_m re)))) (if (<= re 2e+37) (sqrt (* 0.5 (+ re im_m))) (sqrt re))))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if (re <= -1.85e-22) {
tmp = 0.5 * sqrt(((im_m / -1.0) * (im_m / re)));
} else if (re <= 2e+37) {
tmp = sqrt((0.5 * (re + im_m)));
} else {
tmp = sqrt(re);
}
return tmp;
}
im_m = abs(im)
real(8) function code(re, im_m)
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if (re <= (-1.85d-22)) then
tmp = 0.5d0 * sqrt(((im_m / (-1.0d0)) * (im_m / re)))
else if (re <= 2d+37) then
tmp = sqrt((0.5d0 * (re + im_m)))
else
tmp = sqrt(re)
end if
code = tmp
end function
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if (re <= -1.85e-22) {
tmp = 0.5 * Math.sqrt(((im_m / -1.0) * (im_m / re)));
} else if (re <= 2e+37) {
tmp = Math.sqrt((0.5 * (re + im_m)));
} else {
tmp = Math.sqrt(re);
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if re <= -1.85e-22: tmp = 0.5 * math.sqrt(((im_m / -1.0) * (im_m / re))) elif re <= 2e+37: tmp = math.sqrt((0.5 * (re + im_m))) else: tmp = math.sqrt(re) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if (re <= -1.85e-22) tmp = Float64(0.5 * sqrt(Float64(Float64(im_m / -1.0) * Float64(im_m / re)))); elseif (re <= 2e+37) tmp = sqrt(Float64(0.5 * Float64(re + im_m))); else tmp = sqrt(re); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if (re <= -1.85e-22) tmp = 0.5 * sqrt(((im_m / -1.0) * (im_m / re))); elseif (re <= 2e+37) tmp = sqrt((0.5 * (re + im_m))); else tmp = sqrt(re); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[LessEqual[re, -1.85e-22], N[(0.5 * N[Sqrt[N[(N[(im$95$m / -1.0), $MachinePrecision] * N[(im$95$m / re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 2e+37], N[Sqrt[N[(0.5 * N[(re + im$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[re], $MachinePrecision]]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.85 \cdot 10^{-22}:\\
\;\;\;\;0.5 \cdot \sqrt{\frac{im\_m}{-1} \cdot \frac{im\_m}{re}}\\
\mathbf{elif}\;re \leq 2 \cdot 10^{+37}:\\
\;\;\;\;\sqrt{0.5 \cdot \left(re + im\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{re}\\
\end{array}
\end{array}
if re < -1.85e-22Initial program 11.7%
sqr-neg11.7%
+-commutative11.7%
sqr-neg11.7%
+-commutative11.7%
distribute-rgt-in11.7%
cancel-sign-sub11.7%
distribute-rgt-out--11.7%
sub-neg11.7%
remove-double-neg11.7%
+-commutative11.7%
hypot-define36.8%
Simplified36.8%
Taylor expanded in re around -inf 51.3%
mul-1-neg51.3%
distribute-neg-frac251.3%
Simplified51.3%
unpow251.3%
neg-mul-151.3%
times-frac58.2%
Applied egg-rr58.2%
if -1.85e-22 < re < 1.99999999999999991e37Initial program 57.8%
sqr-neg57.8%
+-commutative57.8%
sqr-neg57.8%
+-commutative57.8%
distribute-rgt-in57.8%
cancel-sign-sub57.8%
distribute-rgt-out--57.8%
sub-neg57.8%
remove-double-neg57.8%
+-commutative57.8%
hypot-define87.5%
Simplified87.5%
*-commutative87.5%
hypot-define57.8%
+-commutative57.8%
*-commutative57.8%
add-sqr-sqrt57.4%
sqrt-unprod57.8%
*-commutative57.8%
*-commutative57.8%
swap-sqr57.8%
Applied egg-rr87.5%
*-commutative87.5%
associate-*r*87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in re around 0 43.6%
if 1.99999999999999991e37 < re Initial program 31.9%
sqr-neg31.9%
+-commutative31.9%
sqr-neg31.9%
+-commutative31.9%
distribute-rgt-in31.9%
cancel-sign-sub31.9%
distribute-rgt-out--31.9%
sub-neg31.9%
remove-double-neg31.9%
+-commutative31.9%
hypot-define100.0%
Simplified100.0%
*-commutative100.0%
hypot-define31.9%
+-commutative31.9%
*-commutative31.9%
add-sqr-sqrt31.6%
sqrt-unprod31.9%
*-commutative31.9%
*-commutative31.9%
swap-sqr31.9%
Applied egg-rr100.0%
*-commutative100.0%
associate-*r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in re around inf 77.7%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (<= re -1.8e-22) (* 0.5 (sqrt (/ (* im_m im_m) (- re)))) (if (<= re 3.2e+32) (sqrt (* 0.5 (+ re im_m))) (sqrt re))))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if (re <= -1.8e-22) {
tmp = 0.5 * sqrt(((im_m * im_m) / -re));
} else if (re <= 3.2e+32) {
tmp = sqrt((0.5 * (re + im_m)));
} else {
tmp = sqrt(re);
}
return tmp;
}
im_m = abs(im)
real(8) function code(re, im_m)
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if (re <= (-1.8d-22)) then
tmp = 0.5d0 * sqrt(((im_m * im_m) / -re))
else if (re <= 3.2d+32) then
tmp = sqrt((0.5d0 * (re + im_m)))
else
tmp = sqrt(re)
end if
code = tmp
end function
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if (re <= -1.8e-22) {
tmp = 0.5 * Math.sqrt(((im_m * im_m) / -re));
} else if (re <= 3.2e+32) {
tmp = Math.sqrt((0.5 * (re + im_m)));
} else {
tmp = Math.sqrt(re);
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if re <= -1.8e-22: tmp = 0.5 * math.sqrt(((im_m * im_m) / -re)) elif re <= 3.2e+32: tmp = math.sqrt((0.5 * (re + im_m))) else: tmp = math.sqrt(re) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if (re <= -1.8e-22) tmp = Float64(0.5 * sqrt(Float64(Float64(im_m * im_m) / Float64(-re)))); elseif (re <= 3.2e+32) tmp = sqrt(Float64(0.5 * Float64(re + im_m))); else tmp = sqrt(re); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if (re <= -1.8e-22) tmp = 0.5 * sqrt(((im_m * im_m) / -re)); elseif (re <= 3.2e+32) tmp = sqrt((0.5 * (re + im_m))); else tmp = sqrt(re); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[LessEqual[re, -1.8e-22], N[(0.5 * N[Sqrt[N[(N[(im$95$m * im$95$m), $MachinePrecision] / (-re)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 3.2e+32], N[Sqrt[N[(0.5 * N[(re + im$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Sqrt[re], $MachinePrecision]]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.8 \cdot 10^{-22}:\\
\;\;\;\;0.5 \cdot \sqrt{\frac{im\_m \cdot im\_m}{-re}}\\
\mathbf{elif}\;re \leq 3.2 \cdot 10^{+32}:\\
\;\;\;\;\sqrt{0.5 \cdot \left(re + im\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{re}\\
\end{array}
\end{array}
if re < -1.7999999999999999e-22Initial program 11.7%
sqr-neg11.7%
+-commutative11.7%
sqr-neg11.7%
+-commutative11.7%
distribute-rgt-in11.7%
cancel-sign-sub11.7%
distribute-rgt-out--11.7%
sub-neg11.7%
remove-double-neg11.7%
+-commutative11.7%
hypot-define36.8%
Simplified36.8%
Taylor expanded in re around -inf 51.3%
mul-1-neg51.3%
distribute-neg-frac251.3%
Simplified51.3%
unpow251.3%
Applied egg-rr51.3%
if -1.7999999999999999e-22 < re < 3.1999999999999999e32Initial program 57.8%
sqr-neg57.8%
+-commutative57.8%
sqr-neg57.8%
+-commutative57.8%
distribute-rgt-in57.8%
cancel-sign-sub57.8%
distribute-rgt-out--57.8%
sub-neg57.8%
remove-double-neg57.8%
+-commutative57.8%
hypot-define87.5%
Simplified87.5%
*-commutative87.5%
hypot-define57.8%
+-commutative57.8%
*-commutative57.8%
add-sqr-sqrt57.4%
sqrt-unprod57.8%
*-commutative57.8%
*-commutative57.8%
swap-sqr57.8%
Applied egg-rr87.5%
*-commutative87.5%
associate-*r*87.5%
metadata-eval87.5%
Simplified87.5%
Taylor expanded in re around 0 43.6%
if 3.1999999999999999e32 < re Initial program 31.9%
sqr-neg31.9%
+-commutative31.9%
sqr-neg31.9%
+-commutative31.9%
distribute-rgt-in31.9%
cancel-sign-sub31.9%
distribute-rgt-out--31.9%
sub-neg31.9%
remove-double-neg31.9%
+-commutative31.9%
hypot-define100.0%
Simplified100.0%
*-commutative100.0%
hypot-define31.9%
+-commutative31.9%
*-commutative31.9%
add-sqr-sqrt31.6%
sqrt-unprod31.9%
*-commutative31.9%
*-commutative31.9%
swap-sqr31.9%
Applied egg-rr100.0%
*-commutative100.0%
associate-*r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in re around inf 77.7%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (<= re 3.5e+17) (sqrt (* im_m 0.5)) (sqrt re)))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if (re <= 3.5e+17) {
tmp = sqrt((im_m * 0.5));
} else {
tmp = sqrt(re);
}
return tmp;
}
im_m = abs(im)
real(8) function code(re, im_m)
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if (re <= 3.5d+17) then
tmp = sqrt((im_m * 0.5d0))
else
tmp = sqrt(re)
end if
code = tmp
end function
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if (re <= 3.5e+17) {
tmp = Math.sqrt((im_m * 0.5));
} else {
tmp = Math.sqrt(re);
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if re <= 3.5e+17: tmp = math.sqrt((im_m * 0.5)) else: tmp = math.sqrt(re) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if (re <= 3.5e+17) tmp = sqrt(Float64(im_m * 0.5)); else tmp = sqrt(re); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if (re <= 3.5e+17) tmp = sqrt((im_m * 0.5)); else tmp = sqrt(re); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[LessEqual[re, 3.5e+17], N[Sqrt[N[(im$95$m * 0.5), $MachinePrecision]], $MachinePrecision], N[Sqrt[re], $MachinePrecision]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq 3.5 \cdot 10^{+17}:\\
\;\;\;\;\sqrt{im\_m \cdot 0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{re}\\
\end{array}
\end{array}
if re < 3.5e17Initial program 39.5%
sqr-neg39.5%
+-commutative39.5%
sqr-neg39.5%
+-commutative39.5%
distribute-rgt-in39.5%
cancel-sign-sub39.5%
distribute-rgt-out--39.5%
sub-neg39.5%
remove-double-neg39.5%
+-commutative39.5%
hypot-define67.7%
Simplified67.7%
*-commutative67.7%
hypot-define39.5%
+-commutative39.5%
*-commutative39.5%
add-sqr-sqrt39.3%
sqrt-unprod39.5%
*-commutative39.5%
*-commutative39.5%
swap-sqr39.5%
Applied egg-rr67.7%
*-commutative67.7%
associate-*r*67.7%
metadata-eval67.7%
Simplified67.7%
Taylor expanded in re around 0 30.2%
if 3.5e17 < re Initial program 34.8%
sqr-neg34.8%
+-commutative34.8%
sqr-neg34.8%
+-commutative34.8%
distribute-rgt-in34.8%
cancel-sign-sub34.8%
distribute-rgt-out--34.8%
sub-neg34.8%
remove-double-neg34.8%
+-commutative34.8%
hypot-define100.0%
Simplified100.0%
*-commutative100.0%
hypot-define34.8%
+-commutative34.8%
*-commutative34.8%
add-sqr-sqrt34.5%
sqrt-unprod34.8%
*-commutative34.8%
*-commutative34.8%
swap-sqr34.8%
Applied egg-rr100.0%
*-commutative100.0%
associate-*r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in re around inf 76.7%
Final simplification38.7%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 (if (<= re -5e-310) 0.0 (sqrt re)))
im_m = fabs(im);
double code(double re, double im_m) {
double tmp;
if (re <= -5e-310) {
tmp = 0.0;
} else {
tmp = sqrt(re);
}
return tmp;
}
im_m = abs(im)
real(8) function code(re, im_m)
real(8), intent (in) :: re
real(8), intent (in) :: im_m
real(8) :: tmp
if (re <= (-5d-310)) then
tmp = 0.0d0
else
tmp = sqrt(re)
end if
code = tmp
end function
im_m = Math.abs(im);
public static double code(double re, double im_m) {
double tmp;
if (re <= -5e-310) {
tmp = 0.0;
} else {
tmp = Math.sqrt(re);
}
return tmp;
}
im_m = math.fabs(im) def code(re, im_m): tmp = 0 if re <= -5e-310: tmp = 0.0 else: tmp = math.sqrt(re) return tmp
im_m = abs(im) function code(re, im_m) tmp = 0.0 if (re <= -5e-310) tmp = 0.0; else tmp = sqrt(re); end return tmp end
im_m = abs(im); function tmp_2 = code(re, im_m) tmp = 0.0; if (re <= -5e-310) tmp = 0.0; else tmp = sqrt(re); end tmp_2 = tmp; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := If[LessEqual[re, -5e-310], 0.0, N[Sqrt[re], $MachinePrecision]]
\begin{array}{l}
im_m = \left|im\right|
\\
\begin{array}{l}
\mathbf{if}\;re \leq -5 \cdot 10^{-310}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;\sqrt{re}\\
\end{array}
\end{array}
if re < -4.999999999999985e-310Initial program 27.4%
Taylor expanded in re around -inf 9.7%
mul-1-neg9.7%
Simplified9.7%
Taylor expanded in re around 0 9.7%
metadata-eval9.7%
Applied egg-rr9.7%
if -4.999999999999985e-310 < re Initial program 54.4%
sqr-neg54.4%
+-commutative54.4%
sqr-neg54.4%
+-commutative54.4%
distribute-rgt-in54.4%
cancel-sign-sub54.4%
distribute-rgt-out--54.4%
sub-neg54.4%
remove-double-neg54.4%
+-commutative54.4%
hypot-define100.0%
Simplified100.0%
*-commutative100.0%
hypot-define54.4%
+-commutative54.4%
*-commutative54.4%
add-sqr-sqrt54.0%
sqrt-unprod54.4%
*-commutative54.4%
*-commutative54.4%
swap-sqr54.4%
Applied egg-rr100.0%
*-commutative100.0%
associate-*r*100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in re around inf 47.8%
im_m = (fabs.f64 im) (FPCore (re im_m) :precision binary64 0.0)
im_m = fabs(im);
double code(double re, double im_m) {
return 0.0;
}
im_m = abs(im)
real(8) function code(re, im_m)
real(8), intent (in) :: re
real(8), intent (in) :: im_m
code = 0.0d0
end function
im_m = Math.abs(im);
public static double code(double re, double im_m) {
return 0.0;
}
im_m = math.fabs(im) def code(re, im_m): return 0.0
im_m = abs(im) function code(re, im_m) return 0.0 end
im_m = abs(im); function tmp = code(re, im_m) tmp = 0.0; end
im_m = N[Abs[im], $MachinePrecision] code[re_, im$95$m_] := 0.0
\begin{array}{l}
im_m = \left|im\right|
\\
0
\end{array}
Initial program 38.6%
Taylor expanded in re around -inf 6.8%
mul-1-neg6.8%
Simplified6.8%
Taylor expanded in re around 0 6.8%
metadata-eval6.8%
Applied egg-rr6.8%
(FPCore (re im)
:precision binary64
(let* ((t_0 (sqrt (+ (* re re) (* im im)))))
(if (< re 0.0)
(* 0.5 (* (sqrt 2.0) (sqrt (/ (* im im) (- t_0 re)))))
(* 0.5 (sqrt (* 2.0 (+ t_0 re)))))))
double code(double re, double im) {
double t_0 = sqrt(((re * re) + (im * im)));
double tmp;
if (re < 0.0) {
tmp = 0.5 * (sqrt(2.0) * sqrt(((im * im) / (t_0 - re))));
} else {
tmp = 0.5 * sqrt((2.0 * (t_0 + re)));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt(((re * re) + (im * im)))
if (re < 0.0d0) then
tmp = 0.5d0 * (sqrt(2.0d0) * sqrt(((im * im) / (t_0 - re))))
else
tmp = 0.5d0 * sqrt((2.0d0 * (t_0 + re)))
end if
code = tmp
end function
public static double code(double re, double im) {
double t_0 = Math.sqrt(((re * re) + (im * im)));
double tmp;
if (re < 0.0) {
tmp = 0.5 * (Math.sqrt(2.0) * Math.sqrt(((im * im) / (t_0 - re))));
} else {
tmp = 0.5 * Math.sqrt((2.0 * (t_0 + re)));
}
return tmp;
}
def code(re, im): t_0 = math.sqrt(((re * re) + (im * im))) tmp = 0 if re < 0.0: tmp = 0.5 * (math.sqrt(2.0) * math.sqrt(((im * im) / (t_0 - re)))) else: tmp = 0.5 * math.sqrt((2.0 * (t_0 + re))) return tmp
function code(re, im) t_0 = sqrt(Float64(Float64(re * re) + Float64(im * im))) tmp = 0.0 if (re < 0.0) tmp = Float64(0.5 * Float64(sqrt(2.0) * sqrt(Float64(Float64(im * im) / Float64(t_0 - re))))); else tmp = Float64(0.5 * sqrt(Float64(2.0 * Float64(t_0 + re)))); end return tmp end
function tmp_2 = code(re, im) t_0 = sqrt(((re * re) + (im * im))); tmp = 0.0; if (re < 0.0) tmp = 0.5 * (sqrt(2.0) * sqrt(((im * im) / (t_0 - re)))); else tmp = 0.5 * sqrt((2.0 * (t_0 + re))); end tmp_2 = tmp; end
code[re_, im_] := Block[{t$95$0 = N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[Less[re, 0.0], N[(0.5 * N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(N[(im * im), $MachinePrecision] / N[(t$95$0 - re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(2.0 * N[(t$95$0 + re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{re \cdot re + im \cdot im}\\
\mathbf{if}\;re < 0:\\
\;\;\;\;0.5 \cdot \left(\sqrt{2} \cdot \sqrt{\frac{im \cdot im}{t\_0 - re}}\right)\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(t\_0 + re\right)}\\
\end{array}
\end{array}
herbie shell --seed 2024116
(FPCore (re im)
:name "math.sqrt on complex, real part"
:precision binary64
:alt
(if (< re 0.0) (* 0.5 (* (sqrt 2.0) (sqrt (/ (* im im) (- (sqrt (+ (* re re) (* im im))) re))))) (* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))
(* 0.5 (sqrt (* 2.0 (+ (sqrt (+ (* re re) (* im im))) re)))))