
(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 9 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}
(FPCore (re im) :precision binary64 (if (<= (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)) 0.0) (* 0.5 (/ im (sqrt re))) (* 0.5 (sqrt (- (- (* (hypot im re) 2.0) re) re)))))
double code(double re, double im) {
double tmp;
if ((2.0 * (sqrt(((re * re) + (im * im))) - re)) <= 0.0) {
tmp = 0.5 * (im / sqrt(re));
} else {
tmp = 0.5 * sqrt((((hypot(im, re) * 2.0) - re) - re));
}
return tmp;
}
public static double code(double re, double im) {
double tmp;
if ((2.0 * (Math.sqrt(((re * re) + (im * im))) - re)) <= 0.0) {
tmp = 0.5 * (im / Math.sqrt(re));
} else {
tmp = 0.5 * Math.sqrt((((Math.hypot(im, re) * 2.0) - re) - re));
}
return tmp;
}
def code(re, im): tmp = 0 if (2.0 * (math.sqrt(((re * re) + (im * im))) - re)) <= 0.0: tmp = 0.5 * (im / math.sqrt(re)) else: tmp = 0.5 * math.sqrt((((math.hypot(im, re) * 2.0) - re) - re)) return tmp
function code(re, im) tmp = 0.0 if (Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) - re)) <= 0.0) tmp = Float64(0.5 * Float64(im / sqrt(re))); else tmp = Float64(0.5 * sqrt(Float64(Float64(Float64(hypot(im, re) * 2.0) - re) - re))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if ((2.0 * (sqrt(((re * re) + (im * im))) - re)) <= 0.0) tmp = 0.5 * (im / sqrt(re)); else tmp = 0.5 * sqrt((((hypot(im, re) * 2.0) - re) - re)); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision], 0.0], N[(0.5 * N[(im / N[Sqrt[re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(N[(N[(N[Sqrt[im ^ 2 + re ^ 2], $MachinePrecision] * 2.0), $MachinePrecision] - re), $MachinePrecision] - re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right) \leq 0:\\
\;\;\;\;0.5 \cdot \frac{im}{\sqrt{re}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \sqrt{\left(\mathsf{hypot}\left(im, re\right) \cdot 2 - re\right) - re}\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) < 0.0Initial program 7.8%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6491.4
Applied rewrites91.4%
Applied rewrites92.1%
if 0.0 < (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) Initial program 41.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites92.0%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites92.1%
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+r-N/A
lower--.f64N/A
lower-+.f6492.1
lift-hypot.f64N/A
+-commutativeN/A
lower-hypot.f6492.1
lift-hypot.f64N/A
+-commutativeN/A
lower-hypot.f6492.1
Applied rewrites92.1%
lift-+.f64N/A
count-2N/A
*-commutativeN/A
lower-*.f6492.1
lift-hypot.f64N/A
+-commutativeN/A
lower-hypot.f6492.1
Applied rewrites92.1%
Final simplification92.1%
(FPCore (re im) :precision binary64 (if (<= (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)) 0.0) (* 0.5 (/ im (sqrt re))) (* 0.5 (sqrt (* 2.0 (- (hypot re im) re))))))
double code(double re, double im) {
double tmp;
if ((2.0 * (sqrt(((re * re) + (im * im))) - re)) <= 0.0) {
tmp = 0.5 * (im / sqrt(re));
} else {
tmp = 0.5 * sqrt((2.0 * (hypot(re, im) - re)));
}
return tmp;
}
public static double code(double re, double im) {
double tmp;
if ((2.0 * (Math.sqrt(((re * re) + (im * im))) - re)) <= 0.0) {
tmp = 0.5 * (im / Math.sqrt(re));
} else {
tmp = 0.5 * Math.sqrt((2.0 * (Math.hypot(re, im) - re)));
}
return tmp;
}
def code(re, im): tmp = 0 if (2.0 * (math.sqrt(((re * re) + (im * im))) - re)) <= 0.0: tmp = 0.5 * (im / math.sqrt(re)) else: tmp = 0.5 * math.sqrt((2.0 * (math.hypot(re, im) - re))) return tmp
function code(re, im) tmp = 0.0 if (Float64(2.0 * Float64(sqrt(Float64(Float64(re * re) + Float64(im * im))) - re)) <= 0.0) tmp = Float64(0.5 * Float64(im / sqrt(re))); else tmp = Float64(0.5 * sqrt(Float64(2.0 * Float64(hypot(re, im) - re)))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if ((2.0 * (sqrt(((re * re) + (im * im))) - re)) <= 0.0) tmp = 0.5 * (im / sqrt(re)); else tmp = 0.5 * sqrt((2.0 * (hypot(re, im) - re))); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[N[(2.0 * N[(N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision], 0.0], N[(0.5 * N[(im / N[Sqrt[re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.5 * N[Sqrt[N[(2.0 * N[(N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision] - re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;2 \cdot \left(\sqrt{re \cdot re + im \cdot im} - re\right) \leq 0:\\
\;\;\;\;0.5 \cdot \frac{im}{\sqrt{re}}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \sqrt{2 \cdot \left(\mathsf{hypot}\left(re, im\right) - re\right)}\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) < 0.0Initial program 7.8%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6491.4
Applied rewrites91.4%
Applied rewrites92.1%
if 0.0 < (*.f64 #s(literal 2 binary64) (-.f64 (sqrt.f64 (+.f64 (*.f64 re re) (*.f64 im im))) re)) Initial program 41.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites92.0%
Final simplification92.1%
(FPCore (re im)
:precision binary64
(if (<= re -1.9e-39)
(* 0.5 (sqrt (* -4.0 re)))
(if (<= re 5e-66)
(* 0.5 (sqrt (+ im im)))
(* (* im 0.5) (sqrt (pow re -1.0))))))
double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * sqrt((-4.0 * re));
} else if (re <= 5e-66) {
tmp = 0.5 * sqrt((im + im));
} else {
tmp = (im * 0.5) * sqrt(pow(re, -1.0));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (re <= (-1.9d-39)) then
tmp = 0.5d0 * sqrt(((-4.0d0) * re))
else if (re <= 5d-66) then
tmp = 0.5d0 * sqrt((im + im))
else
tmp = (im * 0.5d0) * sqrt((re ** (-1.0d0)))
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * Math.sqrt((-4.0 * re));
} else if (re <= 5e-66) {
tmp = 0.5 * Math.sqrt((im + im));
} else {
tmp = (im * 0.5) * Math.sqrt(Math.pow(re, -1.0));
}
return tmp;
}
def code(re, im): tmp = 0 if re <= -1.9e-39: tmp = 0.5 * math.sqrt((-4.0 * re)) elif re <= 5e-66: tmp = 0.5 * math.sqrt((im + im)) else: tmp = (im * 0.5) * math.sqrt(math.pow(re, -1.0)) return tmp
function code(re, im) tmp = 0.0 if (re <= -1.9e-39) tmp = Float64(0.5 * sqrt(Float64(-4.0 * re))); elseif (re <= 5e-66) tmp = Float64(0.5 * sqrt(Float64(im + im))); else tmp = Float64(Float64(im * 0.5) * sqrt((re ^ -1.0))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (re <= -1.9e-39) tmp = 0.5 * sqrt((-4.0 * re)); elseif (re <= 5e-66) tmp = 0.5 * sqrt((im + im)); else tmp = (im * 0.5) * sqrt((re ^ -1.0)); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[re, -1.9e-39], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5e-66], N[(0.5 * N[Sqrt[N[(im + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(im * 0.5), $MachinePrecision] * N[Sqrt[N[Power[re, -1.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.9 \cdot 10^{-39}:\\
\;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\
\mathbf{elif}\;re \leq 5 \cdot 10^{-66}:\\
\;\;\;\;0.5 \cdot \sqrt{im + im}\\
\mathbf{else}:\\
\;\;\;\;\left(im \cdot 0.5\right) \cdot \sqrt{{re}^{-1}}\\
\end{array}
\end{array}
if re < -1.9000000000000001e-39Initial program 41.1%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites100.0%
Taylor expanded in re around -inf
lower-*.f6480.0
Applied rewrites80.0%
if -1.9000000000000001e-39 < re < 4.99999999999999962e-66Initial program 44.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites85.9%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites85.9%
Taylor expanded in re around 0
lower-*.f6478.2
Applied rewrites78.2%
Applied rewrites78.2%
if 4.99999999999999962e-66 < re Initial program 16.0%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites39.6%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites39.6%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f6478.0
Applied rewrites78.0%
Final simplification78.8%
(FPCore (re im)
:precision binary64
(if (<= re -1.9e-39)
(* 0.5 (sqrt (* 2.0 (fma (* (/ im re) im) -0.5 (* -2.0 re)))))
(if (<= re 1.06e-66)
(* 0.5 (sqrt (+ (fma (- (/ re im) 2.0) re im) im)))
(* 0.5 (/ im (sqrt re))))))
double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * sqrt((2.0 * fma(((im / re) * im), -0.5, (-2.0 * re))));
} else if (re <= 1.06e-66) {
tmp = 0.5 * sqrt((fma(((re / im) - 2.0), re, im) + im));
} else {
tmp = 0.5 * (im / sqrt(re));
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -1.9e-39) tmp = Float64(0.5 * sqrt(Float64(2.0 * fma(Float64(Float64(im / re) * im), -0.5, Float64(-2.0 * re))))); elseif (re <= 1.06e-66) tmp = Float64(0.5 * sqrt(Float64(fma(Float64(Float64(re / im) - 2.0), re, im) + im))); else tmp = Float64(0.5 * Float64(im / sqrt(re))); end return tmp end
code[re_, im_] := If[LessEqual[re, -1.9e-39], N[(0.5 * N[Sqrt[N[(2.0 * N[(N[(N[(im / re), $MachinePrecision] * im), $MachinePrecision] * -0.5 + N[(-2.0 * re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 1.06e-66], N[(0.5 * N[Sqrt[N[(N[(N[(N[(re / im), $MachinePrecision] - 2.0), $MachinePrecision] * re + im), $MachinePrecision] + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(im / N[Sqrt[re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.9 \cdot 10^{-39}:\\
\;\;\;\;0.5 \cdot \sqrt{2 \cdot \mathsf{fma}\left(\frac{im}{re} \cdot im, -0.5, -2 \cdot re\right)}\\
\mathbf{elif}\;re \leq 1.06 \cdot 10^{-66}:\\
\;\;\;\;0.5 \cdot \sqrt{\mathsf{fma}\left(\frac{re}{im} - 2, re, im\right) + im}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{im}{\sqrt{re}}\\
\end{array}
\end{array}
if re < -1.9000000000000001e-39Initial program 41.1%
Taylor expanded in re around -inf
associate-*r*N/A
mul-1-negN/A
lower-*.f64N/A
lower-neg.f64N/A
+-commutativeN/A
associate-*r/N/A
unpow2N/A
times-fracN/A
metadata-evalN/A
associate-*r/N/A
lower-fma.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6476.1
Applied rewrites76.1%
Taylor expanded in im around 0
Applied rewrites76.1%
Applied rewrites80.1%
if -1.9000000000000001e-39 < re < 1.05999999999999994e-66Initial program 44.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites85.9%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites85.9%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6478.4
Applied rewrites78.4%
Applied rewrites78.4%
if 1.05999999999999994e-66 < re Initial program 16.0%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6477.5
Applied rewrites77.5%
Applied rewrites78.1%
Final simplification78.9%
(FPCore (re im)
:precision binary64
(if (<= re -1.9e-39)
(* 0.5 (sqrt (* -4.0 re)))
(if (<= re 1.06e-66)
(* 0.5 (sqrt (+ (fma (- (/ re im) 2.0) re im) im)))
(* 0.5 (/ im (sqrt re))))))
double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * sqrt((-4.0 * re));
} else if (re <= 1.06e-66) {
tmp = 0.5 * sqrt((fma(((re / im) - 2.0), re, im) + im));
} else {
tmp = 0.5 * (im / sqrt(re));
}
return tmp;
}
function code(re, im) tmp = 0.0 if (re <= -1.9e-39) tmp = Float64(0.5 * sqrt(Float64(-4.0 * re))); elseif (re <= 1.06e-66) tmp = Float64(0.5 * sqrt(Float64(fma(Float64(Float64(re / im) - 2.0), re, im) + im))); else tmp = Float64(0.5 * Float64(im / sqrt(re))); end return tmp end
code[re_, im_] := If[LessEqual[re, -1.9e-39], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 1.06e-66], N[(0.5 * N[Sqrt[N[(N[(N[(N[(re / im), $MachinePrecision] - 2.0), $MachinePrecision] * re + im), $MachinePrecision] + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(im / N[Sqrt[re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.9 \cdot 10^{-39}:\\
\;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\
\mathbf{elif}\;re \leq 1.06 \cdot 10^{-66}:\\
\;\;\;\;0.5 \cdot \sqrt{\mathsf{fma}\left(\frac{re}{im} - 2, re, im\right) + im}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{im}{\sqrt{re}}\\
\end{array}
\end{array}
if re < -1.9000000000000001e-39Initial program 41.1%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites100.0%
Taylor expanded in re around -inf
lower-*.f6480.0
Applied rewrites80.0%
if -1.9000000000000001e-39 < re < 1.05999999999999994e-66Initial program 44.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites85.9%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites85.9%
Taylor expanded in re around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6478.4
Applied rewrites78.4%
Applied rewrites78.4%
if 1.05999999999999994e-66 < re Initial program 16.0%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6477.5
Applied rewrites77.5%
Applied rewrites78.1%
Final simplification78.9%
(FPCore (re im) :precision binary64 (if (<= re -1.9e-39) (* 0.5 (sqrt (* -4.0 re))) (if (<= re 5e-66) (* 0.5 (sqrt (+ im im))) (* 0.5 (/ im (sqrt re))))))
double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * sqrt((-4.0 * re));
} else if (re <= 5e-66) {
tmp = 0.5 * sqrt((im + im));
} else {
tmp = 0.5 * (im / sqrt(re));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (re <= (-1.9d-39)) then
tmp = 0.5d0 * sqrt(((-4.0d0) * re))
else if (re <= 5d-66) then
tmp = 0.5d0 * sqrt((im + im))
else
tmp = 0.5d0 * (im / sqrt(re))
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * Math.sqrt((-4.0 * re));
} else if (re <= 5e-66) {
tmp = 0.5 * Math.sqrt((im + im));
} else {
tmp = 0.5 * (im / Math.sqrt(re));
}
return tmp;
}
def code(re, im): tmp = 0 if re <= -1.9e-39: tmp = 0.5 * math.sqrt((-4.0 * re)) elif re <= 5e-66: tmp = 0.5 * math.sqrt((im + im)) else: tmp = 0.5 * (im / math.sqrt(re)) return tmp
function code(re, im) tmp = 0.0 if (re <= -1.9e-39) tmp = Float64(0.5 * sqrt(Float64(-4.0 * re))); elseif (re <= 5e-66) tmp = Float64(0.5 * sqrt(Float64(im + im))); else tmp = Float64(0.5 * Float64(im / sqrt(re))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (re <= -1.9e-39) tmp = 0.5 * sqrt((-4.0 * re)); elseif (re <= 5e-66) tmp = 0.5 * sqrt((im + im)); else tmp = 0.5 * (im / sqrt(re)); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[re, -1.9e-39], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 5e-66], N[(0.5 * N[Sqrt[N[(im + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.5 * N[(im / N[Sqrt[re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.9 \cdot 10^{-39}:\\
\;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\
\mathbf{elif}\;re \leq 5 \cdot 10^{-66}:\\
\;\;\;\;0.5 \cdot \sqrt{im + im}\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \frac{im}{\sqrt{re}}\\
\end{array}
\end{array}
if re < -1.9000000000000001e-39Initial program 41.1%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites100.0%
Taylor expanded in re around -inf
lower-*.f6480.0
Applied rewrites80.0%
if -1.9000000000000001e-39 < re < 4.99999999999999962e-66Initial program 44.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites85.9%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites85.9%
Taylor expanded in re around 0
lower-*.f6478.2
Applied rewrites78.2%
Applied rewrites78.2%
if 4.99999999999999962e-66 < re Initial program 16.0%
Taylor expanded in re around inf
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6477.5
Applied rewrites77.5%
Applied rewrites78.1%
Final simplification78.8%
(FPCore (re im) :precision binary64 (if (<= re -1.9e-39) (* 0.5 (sqrt (* -4.0 re))) (if (<= re 2.6e+130) (* 0.5 (sqrt (+ im im))) 0.0)))
double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * sqrt((-4.0 * re));
} else if (re <= 2.6e+130) {
tmp = 0.5 * sqrt((im + im));
} else {
tmp = 0.0;
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (re <= (-1.9d-39)) then
tmp = 0.5d0 * sqrt(((-4.0d0) * re))
else if (re <= 2.6d+130) then
tmp = 0.5d0 * sqrt((im + im))
else
tmp = 0.0d0
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (re <= -1.9e-39) {
tmp = 0.5 * Math.sqrt((-4.0 * re));
} else if (re <= 2.6e+130) {
tmp = 0.5 * Math.sqrt((im + im));
} else {
tmp = 0.0;
}
return tmp;
}
def code(re, im): tmp = 0 if re <= -1.9e-39: tmp = 0.5 * math.sqrt((-4.0 * re)) elif re <= 2.6e+130: tmp = 0.5 * math.sqrt((im + im)) else: tmp = 0.0 return tmp
function code(re, im) tmp = 0.0 if (re <= -1.9e-39) tmp = Float64(0.5 * sqrt(Float64(-4.0 * re))); elseif (re <= 2.6e+130) tmp = Float64(0.5 * sqrt(Float64(im + im))); else tmp = 0.0; end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (re <= -1.9e-39) tmp = 0.5 * sqrt((-4.0 * re)); elseif (re <= 2.6e+130) tmp = 0.5 * sqrt((im + im)); else tmp = 0.0; end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[re, -1.9e-39], N[(0.5 * N[Sqrt[N[(-4.0 * re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[re, 2.6e+130], N[(0.5 * N[Sqrt[N[(im + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.0]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \leq -1.9 \cdot 10^{-39}:\\
\;\;\;\;0.5 \cdot \sqrt{-4 \cdot re}\\
\mathbf{elif}\;re \leq 2.6 \cdot 10^{+130}:\\
\;\;\;\;0.5 \cdot \sqrt{im + im}\\
\mathbf{else}:\\
\;\;\;\;0\\
\end{array}
\end{array}
if re < -1.9000000000000001e-39Initial program 41.1%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites100.0%
Taylor expanded in re around -inf
lower-*.f6480.0
Applied rewrites80.0%
if -1.9000000000000001e-39 < re < 2.5999999999999998e130Initial program 38.8%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites72.3%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites72.3%
Taylor expanded in re around 0
lower-*.f6466.0
Applied rewrites66.0%
Applied rewrites66.0%
if 2.5999999999999998e130 < re Initial program 5.6%
Applied rewrites28.3%
Final simplification66.4%
(FPCore (re im) :precision binary64 (if (<= im 1.2e-243) 0.0 (* 0.5 (sqrt (+ im im)))))
double code(double re, double im) {
double tmp;
if (im <= 1.2e-243) {
tmp = 0.0;
} else {
tmp = 0.5 * sqrt((im + im));
}
return tmp;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if (im <= 1.2d-243) then
tmp = 0.0d0
else
tmp = 0.5d0 * sqrt((im + im))
end if
code = tmp
end function
public static double code(double re, double im) {
double tmp;
if (im <= 1.2e-243) {
tmp = 0.0;
} else {
tmp = 0.5 * Math.sqrt((im + im));
}
return tmp;
}
def code(re, im): tmp = 0 if im <= 1.2e-243: tmp = 0.0 else: tmp = 0.5 * math.sqrt((im + im)) return tmp
function code(re, im) tmp = 0.0 if (im <= 1.2e-243) tmp = 0.0; else tmp = Float64(0.5 * sqrt(Float64(im + im))); end return tmp end
function tmp_2 = code(re, im) tmp = 0.0; if (im <= 1.2e-243) tmp = 0.0; else tmp = 0.5 * sqrt((im + im)); end tmp_2 = tmp; end
code[re_, im_] := If[LessEqual[im, 1.2e-243], 0.0, N[(0.5 * N[Sqrt[N[(im + im), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \leq 1.2 \cdot 10^{-243}:\\
\;\;\;\;0\\
\mathbf{else}:\\
\;\;\;\;0.5 \cdot \sqrt{im + im}\\
\end{array}
\end{array}
if im < 1.2e-243Initial program 36.1%
Applied rewrites28.4%
if 1.2e-243 < im Initial program 35.5%
lift-sqrt.f64N/A
lift-+.f64N/A
lift-*.f64N/A
sqr-abs-revN/A
fp-cancel-sign-sub-invN/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
fp-cancel-sub-sign-invN/A
lift-*.f64N/A
rem-sqrt-square-revN/A
pow2N/A
sqrt-pow1N/A
metadata-evalN/A
unpow1N/A
remove-double-negN/A
remove-double-negN/A
remove-double-negN/A
unpow1N/A
metadata-evalN/A
sqrt-pow1N/A
pow2N/A
rem-sqrt-square-revN/A
Applied rewrites78.9%
lift-*.f64N/A
lift--.f64N/A
lift-hypot.f64N/A
count-2-revN/A
lift-hypot.f64N/A
associate-+r-N/A
lower--.f64N/A
Applied rewrites78.9%
Taylor expanded in re around 0
lower-*.f6449.3
Applied rewrites49.3%
Applied rewrites49.3%
Final simplification47.0%
(FPCore (re im) :precision binary64 0.0)
double code(double re, double im) {
return 0.0;
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = 0.0d0
end function
public static double code(double re, double im) {
return 0.0;
}
def code(re, im): return 0.0
function code(re, im) return 0.0 end
function tmp = code(re, im) tmp = 0.0; end
code[re_, im_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 35.6%
Applied rewrites6.6%
herbie shell --seed 2024343
(FPCore (re im)
:name "math.sqrt on complex, imaginary part, im greater than 0 branch"
:precision binary64
:pre (> im 0.0)
(* 0.5 (sqrt (* 2.0 (- (sqrt (+ (* re re) (* im im))) re)))))