
(FPCore (re im) :precision binary64 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))
double code(double re, double im) {
return log(sqrt(((re * re) + (im * im)))) / log(10.0);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = log(sqrt(((re * re) + (im * im)))) / log(10.0d0)
end function
public static double code(double re, double im) {
return Math.log(Math.sqrt(((re * re) + (im * im)))) / Math.log(10.0);
}
def code(re, im): return math.log(math.sqrt(((re * re) + (im * im)))) / math.log(10.0)
function code(re, im) return Float64(log(sqrt(Float64(Float64(re * re) + Float64(im * im)))) / log(10.0)) end
function tmp = code(re, im) tmp = log(sqrt(((re * re) + (im * im)))) / log(10.0); end
code[re_, im_] := N[(N[Log[N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 4 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (re im) :precision binary64 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))
double code(double re, double im) {
return log(sqrt(((re * re) + (im * im)))) / log(10.0);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = log(sqrt(((re * re) + (im * im)))) / log(10.0d0)
end function
public static double code(double re, double im) {
return Math.log(Math.sqrt(((re * re) + (im * im)))) / Math.log(10.0);
}
def code(re, im): return math.log(math.sqrt(((re * re) + (im * im)))) / math.log(10.0)
function code(re, im) return Float64(log(sqrt(Float64(Float64(re * re) + Float64(im * im)))) / log(10.0)) end
function tmp = code(re, im) tmp = log(sqrt(((re * re) + (im * im)))) / log(10.0); end
code[re_, im_] := N[(N[Log[N[Sqrt[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10}
\end{array}
(FPCore (re im) :precision binary64 (* (log (hypot im re)) (sqrt (pow (log 10.0) -2.0))))
double code(double re, double im) {
return log(hypot(im, re)) * sqrt(pow(log(10.0), -2.0));
}
public static double code(double re, double im) {
return Math.log(Math.hypot(im, re)) * Math.sqrt(Math.pow(Math.log(10.0), -2.0));
}
def code(re, im): return math.log(math.hypot(im, re)) * math.sqrt(math.pow(math.log(10.0), -2.0))
function code(re, im) return Float64(log(hypot(im, re)) * sqrt((log(10.0) ^ -2.0))) end
function tmp = code(re, im) tmp = log(hypot(im, re)) * sqrt((log(10.0) ^ -2.0)); end
code[re_, im_] := N[(N[Log[N[Sqrt[im ^ 2 + re ^ 2], $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[Power[N[Log[10.0], $MachinePrecision], -2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log \left(\mathsf{hypot}\left(im, re\right)\right) \cdot \sqrt{{\log 10}^{-2}}
\end{array}
Initial program 50.7%
+-commutative50.7%
+-commutative50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
hypot-define99.1%
Simplified99.1%
clear-num99.0%
inv-pow99.0%
add-sqr-sqrt99.0%
*-un-lft-identity99.0%
times-frac98.7%
unpow-prod-down99.1%
Applied egg-rr99.1%
unpow-199.1%
/-rgt-identity99.1%
associate-*l/98.8%
*-lft-identity98.8%
unpow-198.8%
associate-/r/99.2%
hypot-undefine50.8%
unpow250.8%
unpow250.8%
+-commutative50.8%
unpow250.8%
unpow250.8%
hypot-define99.2%
Simplified99.2%
associate-/l*99.1%
pow1/299.1%
pow-flip99.1%
metadata-eval99.1%
Applied egg-rr99.1%
associate-*r/99.2%
*-commutative99.2%
*-lft-identity99.2%
times-frac99.6%
/-rgt-identity99.6%
Simplified99.6%
add-sqr-sqrt99.6%
sqrt-unprod99.6%
pow1/299.6%
pow-div99.6%
metadata-eval99.6%
inv-pow99.6%
pow1/299.6%
pow-div98.6%
metadata-eval98.6%
inv-pow98.6%
frac-times98.6%
metadata-eval98.6%
pow298.6%
Applied egg-rr98.6%
unpow298.6%
associate-/r*98.6%
*-rgt-identity98.6%
associate-*r/98.6%
unpow-198.6%
unpow-198.6%
pow-sqr99.6%
metadata-eval99.6%
Simplified99.6%
(FPCore (re im) :precision binary64 (* (log (cbrt (hypot im re))) (/ -3.0 (log 0.1))))
double code(double re, double im) {
return log(cbrt(hypot(im, re))) * (-3.0 / log(0.1));
}
public static double code(double re, double im) {
return Math.log(Math.cbrt(Math.hypot(im, re))) * (-3.0 / Math.log(0.1));
}
function code(re, im) return Float64(log(cbrt(hypot(im, re))) * Float64(-3.0 / log(0.1))) end
code[re_, im_] := N[(N[Log[N[Power[N[Sqrt[im ^ 2 + re ^ 2], $MachinePrecision], 1/3], $MachinePrecision]], $MachinePrecision] * N[(-3.0 / N[Log[0.1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\log \left(\sqrt[3]{\mathsf{hypot}\left(im, re\right)}\right) \cdot \frac{-3}{\log 0.1}
\end{array}
Initial program 50.7%
+-commutative50.7%
+-commutative50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
hypot-define99.1%
Simplified99.1%
clear-num99.0%
inv-pow99.0%
add-sqr-sqrt99.0%
*-un-lft-identity99.0%
times-frac98.7%
unpow-prod-down99.1%
Applied egg-rr99.1%
unpow-199.1%
/-rgt-identity99.1%
associate-*l/98.8%
*-lft-identity98.8%
unpow-198.8%
associate-/r/99.2%
hypot-undefine50.8%
unpow250.8%
unpow250.8%
+-commutative50.8%
unpow250.8%
unpow250.8%
hypot-define99.2%
Simplified99.2%
add-log-exp99.2%
*-commutative99.2%
exp-to-pow99.2%
hypot-undefine50.8%
+-commutative50.8%
hypot-undefine99.2%
exp-to-pow99.2%
div-inv98.8%
add-log-exp98.8%
associate-/r*99.1%
add-sqr-sqrt99.1%
div-inv98.6%
add-log-exp98.5%
exp-to-pow98.5%
Applied egg-rr99.1%
*-commutative99.1%
associate-*l/99.1%
associate-*r/98.9%
Simplified98.9%
associate-*r/99.1%
frac-2neg99.1%
neg-log99.0%
metadata-eval99.0%
Applied egg-rr99.0%
distribute-rgt-neg-in99.0%
metadata-eval99.0%
associate-/l*99.3%
Simplified99.3%
(FPCore (re im) :precision binary64 (/ (log (hypot re im)) (log 10.0)))
double code(double re, double im) {
return log(hypot(re, im)) / log(10.0);
}
public static double code(double re, double im) {
return Math.log(Math.hypot(re, im)) / Math.log(10.0);
}
def code(re, im): return math.log(math.hypot(re, im)) / math.log(10.0)
function code(re, im) return Float64(log(hypot(re, im)) / log(10.0)) end
function tmp = code(re, im) tmp = log(hypot(re, im)) / log(10.0); end
code[re_, im_] := N[(N[Log[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\log \left(\mathsf{hypot}\left(re, im\right)\right)}{\log 10}
\end{array}
Initial program 50.7%
+-commutative50.7%
+-commutative50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
hypot-define99.1%
Simplified99.1%
(FPCore (re im) :precision binary64 (/ (log im) (log 10.0)))
double code(double re, double im) {
return log(im) / log(10.0);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = log(im) / log(10.0d0)
end function
public static double code(double re, double im) {
return Math.log(im) / Math.log(10.0);
}
def code(re, im): return math.log(im) / math.log(10.0)
function code(re, im) return Float64(log(im) / log(10.0)) end
function tmp = code(re, im) tmp = log(im) / log(10.0); end
code[re_, im_] := N[(N[Log[im], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\log im}{\log 10}
\end{array}
Initial program 50.7%
+-commutative50.7%
+-commutative50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
sqr-neg50.7%
hypot-define99.1%
Simplified99.1%
Taylor expanded in re around 0 25.2%
herbie shell --seed 2024139
(FPCore (re im)
:name "math.log10 on complex, real part"
:precision binary64
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))