
(FPCore re_sqr (re im) :precision binary64 (- (* re re) (* im im)))
double re_sqr(double re, double im) {
return (re * re) - (im * im);
}
real(8) function re_sqr(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
re_sqr = (re * re) - (im * im)
end function
public static double re_sqr(double re, double im) {
return (re * re) - (im * im);
}
def re_sqr(re, im): return (re * re) - (im * im)
function re_sqr(re, im) return Float64(Float64(re * re) - Float64(im * im)) end
function tmp = re_sqr(re, im) tmp = (re * re) - (im * im); end
re$95$sqr[re_, im_] := N[(N[(re * re), $MachinePrecision] - N[(im * im), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
re \cdot re - im \cdot im
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 4 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore re_sqr (re im) :precision binary64 (- (* re re) (* im im)))
double re_sqr(double re, double im) {
return (re * re) - (im * im);
}
real(8) function re_sqr(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
re_sqr = (re * re) - (im * im)
end function
public static double re_sqr(double re, double im) {
return (re * re) - (im * im);
}
def re_sqr(re, im): return (re * re) - (im * im)
function re_sqr(re, im) return Float64(Float64(re * re) - Float64(im * im)) end
function tmp = re_sqr(re, im) tmp = (re * re) - (im * im); end
re$95$sqr[re_, im_] := N[(N[(re * re), $MachinePrecision] - N[(im * im), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
re \cdot re - im \cdot im
\end{array}
(FPCore re_sqr (re im) :precision binary64 (if (<= (* im im) 2e+300) (fma re re (* im (- im))) (* re (* re (- 1.0 (* (/ im re) (/ im re)))))))
double re_sqr(double re, double im) {
double tmp;
if ((im * im) <= 2e+300) {
tmp = fma(re, re, (im * -im));
} else {
tmp = re * (re * (1.0 - ((im / re) * (im / re))));
}
return tmp;
}
function re_sqr(re, im) tmp = 0.0 if (Float64(im * im) <= 2e+300) tmp = fma(re, re, Float64(im * Float64(-im))); else tmp = Float64(re * Float64(re * Float64(1.0 - Float64(Float64(im / re) * Float64(im / re))))); end return tmp end
re$95$sqr[re_, im_] := If[LessEqual[N[(im * im), $MachinePrecision], 2e+300], N[(re * re + N[(im * (-im)), $MachinePrecision]), $MachinePrecision], N[(re * N[(re * N[(1.0 - N[(N[(im / re), $MachinePrecision] * N[(im / re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \cdot im \leq 2 \cdot 10^{+300}:\\
\;\;\;\;\mathsf{fma}\left(re, re, im \cdot \left(-im\right)\right)\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(re \cdot \left(1 - \frac{im}{re} \cdot \frac{im}{re}\right)\right)\\
\end{array}
\end{array}
if (*.f64 im im) < 2.0000000000000001e300Initial program 100.0%
sqr-neg100.0%
cancel-sign-sub100.0%
fma-define100.0%
Simplified100.0%
if 2.0000000000000001e300 < (*.f64 im im) Initial program 76.0%
Taylor expanded in re around inf 53.5%
mul-1-neg53.5%
unsub-neg53.5%
Simplified53.5%
add-sqr-sqrt1.4%
pow21.4%
sqrt-prod1.4%
sqrt-pow11.4%
metadata-eval1.4%
pow11.4%
add-sqr-sqrt1.4%
pow21.4%
sqrt-div1.4%
sqrt-pow111.3%
metadata-eval11.3%
pow111.3%
sqrt-pow111.3%
metadata-eval11.3%
pow111.3%
Applied egg-rr11.3%
unpow211.3%
*-commutative11.3%
*-commutative11.3%
swap-sqr11.2%
pow211.2%
pow211.2%
add-sqr-sqrt77.4%
associate-*r*100.0%
pow2100.0%
Applied egg-rr100.0%
pow2100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore re_sqr (re im) :precision binary64 (if (<= (* im im) 2e+300) (- (* re re) (* im im)) (* re (* re (- 1.0 (* (/ im re) (/ im re)))))))
double re_sqr(double re, double im) {
double tmp;
if ((im * im) <= 2e+300) {
tmp = (re * re) - (im * im);
} else {
tmp = re * (re * (1.0 - ((im / re) * (im / re))));
}
return tmp;
}
real(8) function re_sqr(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if ((im * im) <= 2d+300) then
tmp = (re * re) - (im * im)
else
tmp = re * (re * (1.0d0 - ((im / re) * (im / re))))
end if
re_sqr = tmp
end function
public static double re_sqr(double re, double im) {
double tmp;
if ((im * im) <= 2e+300) {
tmp = (re * re) - (im * im);
} else {
tmp = re * (re * (1.0 - ((im / re) * (im / re))));
}
return tmp;
}
def re_sqr(re, im): tmp = 0 if (im * im) <= 2e+300: tmp = (re * re) - (im * im) else: tmp = re * (re * (1.0 - ((im / re) * (im / re)))) return tmp
function re_sqr(re, im) tmp = 0.0 if (Float64(im * im) <= 2e+300) tmp = Float64(Float64(re * re) - Float64(im * im)); else tmp = Float64(re * Float64(re * Float64(1.0 - Float64(Float64(im / re) * Float64(im / re))))); end return tmp end
function tmp_2 = re_sqr(re, im) tmp = 0.0; if ((im * im) <= 2e+300) tmp = (re * re) - (im * im); else tmp = re * (re * (1.0 - ((im / re) * (im / re)))); end tmp_2 = tmp; end
re$95$sqr[re_, im_] := If[LessEqual[N[(im * im), $MachinePrecision], 2e+300], N[(N[(re * re), $MachinePrecision] - N[(im * im), $MachinePrecision]), $MachinePrecision], N[(re * N[(re * N[(1.0 - N[(N[(im / re), $MachinePrecision] * N[(im / re), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;im \cdot im \leq 2 \cdot 10^{+300}:\\
\;\;\;\;re \cdot re - im \cdot im\\
\mathbf{else}:\\
\;\;\;\;re \cdot \left(re \cdot \left(1 - \frac{im}{re} \cdot \frac{im}{re}\right)\right)\\
\end{array}
\end{array}
if (*.f64 im im) < 2.0000000000000001e300Initial program 100.0%
if 2.0000000000000001e300 < (*.f64 im im) Initial program 76.0%
Taylor expanded in re around inf 53.5%
mul-1-neg53.5%
unsub-neg53.5%
Simplified53.5%
add-sqr-sqrt1.4%
pow21.4%
sqrt-prod1.4%
sqrt-pow11.4%
metadata-eval1.4%
pow11.4%
add-sqr-sqrt1.4%
pow21.4%
sqrt-div1.4%
sqrt-pow111.3%
metadata-eval11.3%
pow111.3%
sqrt-pow111.3%
metadata-eval11.3%
pow111.3%
Applied egg-rr11.3%
unpow211.3%
*-commutative11.3%
*-commutative11.3%
swap-sqr11.2%
pow211.2%
pow211.2%
add-sqr-sqrt77.4%
associate-*r*100.0%
pow2100.0%
Applied egg-rr100.0%
pow2100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore re_sqr (re im) :precision binary64 (if (<= (* re re) 5e+302) (- (* re re) (* im im)) (* re re)))
double re_sqr(double re, double im) {
double tmp;
if ((re * re) <= 5e+302) {
tmp = (re * re) - (im * im);
} else {
tmp = re * re;
}
return tmp;
}
real(8) function re_sqr(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8) :: tmp
if ((re * re) <= 5d+302) then
tmp = (re * re) - (im * im)
else
tmp = re * re
end if
re_sqr = tmp
end function
public static double re_sqr(double re, double im) {
double tmp;
if ((re * re) <= 5e+302) {
tmp = (re * re) - (im * im);
} else {
tmp = re * re;
}
return tmp;
}
def re_sqr(re, im): tmp = 0 if (re * re) <= 5e+302: tmp = (re * re) - (im * im) else: tmp = re * re return tmp
function re_sqr(re, im) tmp = 0.0 if (Float64(re * re) <= 5e+302) tmp = Float64(Float64(re * re) - Float64(im * im)); else tmp = Float64(re * re); end return tmp end
function tmp_2 = re_sqr(re, im) tmp = 0.0; if ((re * re) <= 5e+302) tmp = (re * re) - (im * im); else tmp = re * re; end tmp_2 = tmp; end
re$95$sqr[re_, im_] := If[LessEqual[N[(re * re), $MachinePrecision], 5e+302], N[(N[(re * re), $MachinePrecision] - N[(im * im), $MachinePrecision]), $MachinePrecision], N[(re * re), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;re \cdot re \leq 5 \cdot 10^{+302}:\\
\;\;\;\;re \cdot re - im \cdot im\\
\mathbf{else}:\\
\;\;\;\;re \cdot re\\
\end{array}
\end{array}
if (*.f64 re re) < 5e302Initial program 100.0%
if 5e302 < (*.f64 re re) Initial program 73.8%
Taylor expanded in re around inf 73.8%
mul-1-neg73.8%
unsub-neg73.8%
Simplified73.8%
add-sqr-sqrt73.8%
pow273.8%
sqrt-prod73.8%
sqrt-pow173.8%
metadata-eval73.8%
pow173.8%
add-sqr-sqrt73.8%
pow273.8%
sqrt-div73.8%
sqrt-pow184.6%
metadata-eval84.6%
pow184.6%
sqrt-pow184.6%
metadata-eval84.6%
pow184.6%
Applied egg-rr84.6%
unpow284.6%
*-commutative84.6%
*-commutative84.6%
swap-sqr84.6%
pow284.6%
pow284.6%
add-sqr-sqrt100.0%
associate-*r*100.0%
pow2100.0%
Applied egg-rr100.0%
Taylor expanded in im around 0 84.6%
Final simplification96.1%
(FPCore re_sqr (re im) :precision binary64 (* re re))
double re_sqr(double re, double im) {
return re * re;
}
real(8) function re_sqr(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
re_sqr = re * re
end function
public static double re_sqr(double re, double im) {
return re * re;
}
def re_sqr(re, im): return re * re
function re_sqr(re, im) return Float64(re * re) end
function tmp = re_sqr(re, im) tmp = re * re; end
re$95$sqr[re_, im_] := N[(re * re), $MachinePrecision]
\begin{array}{l}
\\
re \cdot re
\end{array}
Initial program 93.3%
Taylor expanded in re around inf 66.9%
mul-1-neg66.9%
unsub-neg66.9%
Simplified66.9%
add-sqr-sqrt40.6%
pow240.6%
sqrt-prod40.6%
sqrt-pow140.6%
metadata-eval40.6%
pow140.6%
add-sqr-sqrt40.6%
pow240.6%
sqrt-div40.6%
sqrt-pow143.4%
metadata-eval43.4%
pow143.4%
sqrt-pow145.3%
metadata-eval45.3%
pow145.3%
Applied egg-rr45.3%
unpow245.3%
*-commutative45.3%
*-commutative45.3%
swap-sqr45.3%
pow245.3%
pow245.3%
add-sqr-sqrt78.0%
associate-*r*87.9%
pow287.9%
Applied egg-rr87.9%
Taylor expanded in im around 0 48.0%
Final simplification48.0%
herbie shell --seed 2024075
(FPCore re_sqr (re im)
:name "math.square on complex, real part"
:precision binary64
(- (* re re) (* im im)))