
(FPCore (re im base) :precision binary64 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0.0)) (+ (* (log base) (log base)) (* 0.0 0.0))))
double code(double re, double im, double base) {
return ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0)) / ((log(base) * log(base)) + (0.0 * 0.0));
}
real(8) function code(re, im, base)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8), intent (in) :: base
code = ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0d0)) / ((log(base) * log(base)) + (0.0d0 * 0.0d0))
end function
public static double code(double re, double im, double base) {
return ((Math.atan2(im, re) * Math.log(base)) - (Math.log(Math.sqrt(((re * re) + (im * im)))) * 0.0)) / ((Math.log(base) * Math.log(base)) + (0.0 * 0.0));
}
def code(re, im, base): return ((math.atan2(im, re) * math.log(base)) - (math.log(math.sqrt(((re * re) + (im * im)))) * 0.0)) / ((math.log(base) * math.log(base)) + (0.0 * 0.0))
function code(re, im, base) return Float64(Float64(Float64(atan(im, re) * log(base)) - Float64(log(sqrt(Float64(Float64(re * re) + Float64(im * im)))) * 0.0)) / Float64(Float64(log(base) * log(base)) + Float64(0.0 * 0.0))) end
function tmp = code(re, im, base) tmp = ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0)) / ((log(base) * log(base)) + (0.0 * 0.0)); end
code[re_, im_, base_] := N[(N[(N[(N[ArcTan[im / re], $MachinePrecision] * N[Log[base], $MachinePrecision]), $MachinePrecision] - N[(N[Log[N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * 0.0), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Log[base], $MachinePrecision] * N[Log[base], $MachinePrecision]), $MachinePrecision] + N[(0.0 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\tan^{-1}_* \frac{im}{re} \cdot \log base - \log \left(\sqrt{re \cdot re + im \cdot im}\right) \cdot 0}{\log base \cdot \log base + 0 \cdot 0}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 3 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im base) :precision binary64 (/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0.0)) (+ (* (log base) (log base)) (* 0.0 0.0))))
double code(double re, double im, double base) {
return ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0)) / ((log(base) * log(base)) + (0.0 * 0.0));
}
real(8) function code(re, im, base)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8), intent (in) :: base
code = ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0d0)) / ((log(base) * log(base)) + (0.0d0 * 0.0d0))
end function
public static double code(double re, double im, double base) {
return ((Math.atan2(im, re) * Math.log(base)) - (Math.log(Math.sqrt(((re * re) + (im * im)))) * 0.0)) / ((Math.log(base) * Math.log(base)) + (0.0 * 0.0));
}
def code(re, im, base): return ((math.atan2(im, re) * math.log(base)) - (math.log(math.sqrt(((re * re) + (im * im)))) * 0.0)) / ((math.log(base) * math.log(base)) + (0.0 * 0.0))
function code(re, im, base) return Float64(Float64(Float64(atan(im, re) * log(base)) - Float64(log(sqrt(Float64(Float64(re * re) + Float64(im * im)))) * 0.0)) / Float64(Float64(log(base) * log(base)) + Float64(0.0 * 0.0))) end
function tmp = code(re, im, base) tmp = ((atan2(im, re) * log(base)) - (log(sqrt(((re * re) + (im * im)))) * 0.0)) / ((log(base) * log(base)) + (0.0 * 0.0)); end
code[re_, im_, base_] := N[(N[(N[(N[ArcTan[im / re], $MachinePrecision] * N[Log[base], $MachinePrecision]), $MachinePrecision] - N[(N[Log[N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * 0.0), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Log[base], $MachinePrecision] * N[Log[base], $MachinePrecision]), $MachinePrecision] + N[(0.0 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\tan^{-1}_* \frac{im}{re} \cdot \log base - \log \left(\sqrt{re \cdot re + im \cdot im}\right) \cdot 0}{\log base \cdot \log base + 0 \cdot 0}
\end{array}
(FPCore (re im base) :precision binary64 (/ (atan2 im re) (log base)))
double code(double re, double im, double base) {
return atan2(im, re) / log(base);
}
real(8) function code(re, im, base)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8), intent (in) :: base
code = atan2(im, re) / log(base)
end function
public static double code(double re, double im, double base) {
return Math.atan2(im, re) / Math.log(base);
}
def code(re, im, base): return math.atan2(im, re) / math.log(base)
function code(re, im, base) return Float64(atan(im, re) / log(base)) end
function tmp = code(re, im, base) tmp = atan2(im, re) / log(base); end
code[re_, im_, base_] := N[(N[ArcTan[im / re], $MachinePrecision] / N[Log[base], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\tan^{-1}_* \frac{im}{re}}{\log base}
\end{array}
Initial program 51.6%
mul0-rgt99.4%
--rgt-identity99.4%
metadata-eval99.4%
+-rgt-identity99.4%
times-frac99.5%
*-inverses99.5%
*-rgt-identity99.5%
Simplified99.5%
(FPCore (re im base) :precision binary64 (if (<= base 0.12) (fabs (atan2 im re)) (atan2 im re)))
double code(double re, double im, double base) {
double tmp;
if (base <= 0.12) {
tmp = fabs(atan2(im, re));
} else {
tmp = atan2(im, re);
}
return tmp;
}
real(8) function code(re, im, base)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8), intent (in) :: base
real(8) :: tmp
if (base <= 0.12d0) then
tmp = abs(atan2(im, re))
else
tmp = atan2(im, re)
end if
code = tmp
end function
public static double code(double re, double im, double base) {
double tmp;
if (base <= 0.12) {
tmp = Math.abs(Math.atan2(im, re));
} else {
tmp = Math.atan2(im, re);
}
return tmp;
}
def code(re, im, base): tmp = 0 if base <= 0.12: tmp = math.fabs(math.atan2(im, re)) else: tmp = math.atan2(im, re) return tmp
function code(re, im, base) tmp = 0.0 if (base <= 0.12) tmp = abs(atan(im, re)); else tmp = atan(im, re); end return tmp end
function tmp_2 = code(re, im, base) tmp = 0.0; if (base <= 0.12) tmp = abs(atan2(im, re)); else tmp = atan2(im, re); end tmp_2 = tmp; end
code[re_, im_, base_] := If[LessEqual[base, 0.12], N[Abs[N[ArcTan[im / re], $MachinePrecision]], $MachinePrecision], N[ArcTan[im / re], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;base \leq 0.12:\\
\;\;\;\;\left|\tan^{-1}_* \frac{im}{re}\right|\\
\mathbf{else}:\\
\;\;\;\;\tan^{-1}_* \frac{im}{re}\\
\end{array}
\end{array}
if base < 0.12Initial program 52.3%
mul0-rgt99.3%
--rgt-identity99.3%
associate-/l*99.2%
metadata-eval99.2%
+-rgt-identity99.2%
associate-/r*99.3%
*-inverses99.3%
Simplified99.3%
div-inv99.5%
clear-num98.9%
Applied egg-rr98.9%
clear-num98.8%
associate-/r/98.8%
Applied egg-rr98.8%
associate-*l/98.9%
*-un-lft-identity98.9%
clear-num99.5%
*-un-lft-identity99.5%
add-sqr-sqrt0.0%
times-frac0.0%
metadata-eval0.0%
sqrt-div0.0%
add-exp-log0.0%
neg-log0.0%
add-sqr-sqrt0.0%
sqrt-unprod0.0%
sqr-neg0.0%
sqrt-unprod0.0%
add-sqr-sqrt0.0%
add-exp-log0.0%
Applied egg-rr0.0%
*-commutative0.0%
associate-*l/0.0%
associate-/l*0.0%
*-inverses10.1%
*-rgt-identity10.1%
Simplified10.1%
add-sqr-sqrt7.4%
sqrt-unprod15.7%
pow215.7%
Applied egg-rr15.7%
unpow215.7%
rem-sqrt-square15.6%
Simplified15.6%
if 0.12 < base Initial program 51.0%
mul0-rgt99.5%
--rgt-identity99.5%
associate-/l*99.3%
metadata-eval99.3%
+-rgt-identity99.3%
associate-/r*99.5%
*-inverses99.5%
Simplified99.5%
div-inv99.6%
clear-num99.0%
Applied egg-rr99.0%
clear-num99.0%
associate-/r/98.9%
Applied egg-rr98.9%
associate-*l/99.0%
*-un-lft-identity99.0%
clear-num99.6%
*-un-lft-identity99.6%
add-sqr-sqrt98.4%
times-frac98.3%
metadata-eval98.3%
sqrt-div98.4%
add-exp-log98.2%
neg-log98.2%
add-sqr-sqrt0.0%
sqrt-unprod21.7%
sqr-neg21.7%
sqrt-unprod21.7%
add-sqr-sqrt21.7%
add-exp-log21.7%
Applied egg-rr21.7%
*-commutative21.7%
associate-*l/21.7%
associate-/l*21.7%
*-inverses21.7%
*-rgt-identity21.7%
Simplified21.7%
(FPCore (re im base) :precision binary64 (atan2 im re))
double code(double re, double im, double base) {
return atan2(im, re);
}
real(8) function code(re, im, base)
real(8), intent (in) :: re
real(8), intent (in) :: im
real(8), intent (in) :: base
code = atan2(im, re)
end function
public static double code(double re, double im, double base) {
return Math.atan2(im, re);
}
def code(re, im, base): return math.atan2(im, re)
function code(re, im, base) return atan(im, re) end
function tmp = code(re, im, base) tmp = atan2(im, re); end
code[re_, im_, base_] := N[ArcTan[im / re], $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{im}{re}
\end{array}
Initial program 51.6%
mul0-rgt99.4%
--rgt-identity99.4%
associate-/l*99.3%
metadata-eval99.3%
+-rgt-identity99.3%
associate-/r*99.4%
*-inverses99.4%
Simplified99.4%
div-inv99.5%
clear-num98.9%
Applied egg-rr98.9%
clear-num98.9%
associate-/r/98.9%
Applied egg-rr98.9%
associate-*l/98.9%
*-un-lft-identity98.9%
clear-num99.5%
*-un-lft-identity99.5%
add-sqr-sqrt48.0%
times-frac48.0%
metadata-eval48.0%
sqrt-div48.1%
add-exp-log47.9%
neg-log47.9%
add-sqr-sqrt0.0%
sqrt-unprod10.6%
sqr-neg10.6%
sqrt-unprod10.6%
add-sqr-sqrt10.6%
add-exp-log10.6%
Applied egg-rr10.6%
*-commutative10.6%
associate-*l/10.6%
associate-/l*10.6%
*-inverses15.7%
*-rgt-identity15.7%
Simplified15.7%
herbie shell --seed 2024186
(FPCore (re im base)
:name "math.log/2 on complex, imaginary part"
:precision binary64
(/ (- (* (atan2 im re) (log base)) (* (log (sqrt (+ (* re re) (* im im)))) 0.0)) (+ (* (log base) (log base)) (* 0.0 0.0))))