
(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 5 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 (pow (hypot re im) (/ -0.3333333333333333 (log 0.1)))) 3.0))
double code(double re, double im) {
return log(pow(hypot(re, im), (-0.3333333333333333 / log(0.1)))) * 3.0;
}
public static double code(double re, double im) {
return Math.log(Math.pow(Math.hypot(re, im), (-0.3333333333333333 / Math.log(0.1)))) * 3.0;
}
def code(re, im): return math.log(math.pow(math.hypot(re, im), (-0.3333333333333333 / math.log(0.1)))) * 3.0
function code(re, im) return Float64(log((hypot(re, im) ^ Float64(-0.3333333333333333 / log(0.1)))) * 3.0) end
function tmp = code(re, im) tmp = log((hypot(re, im) ^ (-0.3333333333333333 / log(0.1)))) * 3.0; end
code[re_, im_] := N[(N[Log[N[Power[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision], N[(-0.3333333333333333 / N[Log[0.1], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * 3.0), $MachinePrecision]
\begin{array}{l}
\\
\log \left({\left(\mathsf{hypot}\left(re, im\right)\right)}^{\left(\frac{-0.3333333333333333}{\log 0.1}\right)}\right) \cdot 3
\end{array}
Initial program 52.3%
+-commutative52.3%
+-commutative52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.1%
log-prod99.1%
pow299.1%
div-inv98.7%
exp-to-pow98.8%
div-inv98.6%
exp-to-pow98.6%
Applied egg-rr98.6%
log-pow98.6%
distribute-lft1-in98.6%
metadata-eval98.6%
*-commutative98.6%
Simplified98.6%
pow1/398.2%
pow-pow98.6%
frac-2neg98.6%
metadata-eval98.6%
neg-log99.5%
metadata-eval99.5%
Applied egg-rr99.5%
associate-*l/99.5%
metadata-eval99.5%
Simplified99.5%
Final simplification99.5%
(FPCore (re im) :precision binary64 (/ (* 3.0 (log (hypot re im))) (log 1000.0)))
double code(double re, double im) {
return (3.0 * log(hypot(re, im))) / log(1000.0);
}
public static double code(double re, double im) {
return (3.0 * Math.log(Math.hypot(re, im))) / Math.log(1000.0);
}
def code(re, im): return (3.0 * math.log(math.hypot(re, im))) / math.log(1000.0)
function code(re, im) return Float64(Float64(3.0 * log(hypot(re, im))) / log(1000.0)) end
function tmp = code(re, im) tmp = (3.0 * log(hypot(re, im))) / log(1000.0); end
code[re_, im_] := N[(N[(3.0 * N[Log[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Log[1000.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{3 \cdot \log \left(\mathsf{hypot}\left(re, im\right)\right)}{\log 1000}
\end{array}
Initial program 52.3%
+-commutative52.3%
+-commutative52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.1%
log-prod99.1%
pow299.1%
div-inv98.7%
exp-to-pow98.8%
div-inv98.6%
exp-to-pow98.6%
Applied egg-rr98.6%
log-pow98.6%
distribute-lft1-in98.6%
metadata-eval98.6%
*-commutative98.6%
Simplified98.6%
pow1/398.2%
pow-pow98.6%
frac-2neg98.6%
metadata-eval98.6%
neg-log99.5%
metadata-eval99.5%
Applied egg-rr99.5%
associate-*l/99.5%
metadata-eval99.5%
Simplified99.5%
expm1-log1p-u64.0%
expm1-udef64.1%
log-pow64.1%
associate-*l*64.1%
Applied egg-rr64.1%
expm1-def64.1%
expm1-log1p99.2%
*-commutative99.2%
Simplified99.2%
expm1-log1p-u64.1%
expm1-udef64.1%
Applied egg-rr14.7%
expm1-def14.7%
expm1-log1p33.2%
log-pow99.3%
Simplified99.3%
Final simplification99.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 52.3%
+-commutative52.3%
+-commutative52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
hypot-def99.1%
Simplified99.1%
Final simplification99.1%
(FPCore (re im) :precision binary64 (* (/ 3.0 (log 1000.0)) (log im)))
double code(double re, double im) {
return (3.0 / log(1000.0)) * log(im);
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = (3.0d0 / log(1000.0d0)) * log(im)
end function
public static double code(double re, double im) {
return (3.0 / Math.log(1000.0)) * Math.log(im);
}
def code(re, im): return (3.0 / math.log(1000.0)) * math.log(im)
function code(re, im) return Float64(Float64(3.0 / log(1000.0)) * log(im)) end
function tmp = code(re, im) tmp = (3.0 / log(1000.0)) * log(im); end
code[re_, im_] := N[(N[(3.0 / N[Log[1000.0], $MachinePrecision]), $MachinePrecision] * N[Log[im], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{3}{\log 1000} \cdot \log im
\end{array}
Initial program 52.3%
+-commutative52.3%
+-commutative52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
hypot-def99.1%
Simplified99.1%
Taylor expanded in re around 0 25.9%
clear-num25.9%
inv-pow25.9%
Applied egg-rr25.9%
unpow-125.9%
Simplified25.9%
associate-/r/25.8%
metadata-eval25.8%
associate-*l/25.8%
clear-num25.8%
associate-*l/25.8%
metadata-eval25.8%
add-log-exp25.8%
div-inv25.8%
metadata-eval25.8%
exp-to-pow26.1%
metadata-eval26.1%
Applied egg-rr26.1%
Final simplification26.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 52.3%
+-commutative52.3%
+-commutative52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
sqr-neg52.3%
hypot-def99.1%
Simplified99.1%
Taylor expanded in re around 0 25.9%
Final simplification25.9%
herbie shell --seed 2023298
(FPCore (re im)
:name "math.log10 on complex, real part"
:precision binary64
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))