
(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 49.3%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.0%
log-prod99.0%
pow299.0%
div-inv98.6%
exp-to-pow98.7%
div-inv98.5%
exp-to-pow98.5%
Applied egg-rr98.5%
log-pow98.5%
distribute-lft1-in98.5%
metadata-eval98.5%
*-commutative98.5%
Simplified98.5%
pow1/398.1%
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 (* (/ -0.3333333333333333 (log 0.1)) (* 3.0 (log (hypot re im)))))
double code(double re, double im) {
return (-0.3333333333333333 / log(0.1)) * (3.0 * log(hypot(re, im)));
}
public static double code(double re, double im) {
return (-0.3333333333333333 / Math.log(0.1)) * (3.0 * Math.log(Math.hypot(re, im)));
}
def code(re, im): return (-0.3333333333333333 / math.log(0.1)) * (3.0 * math.log(math.hypot(re, im)))
function code(re, im) return Float64(Float64(-0.3333333333333333 / log(0.1)) * Float64(3.0 * log(hypot(re, im)))) end
function tmp = code(re, im) tmp = (-0.3333333333333333 / log(0.1)) * (3.0 * log(hypot(re, im))); end
code[re_, im_] := N[(N[(-0.3333333333333333 / N[Log[0.1], $MachinePrecision]), $MachinePrecision] * N[(3.0 * N[Log[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{-0.3333333333333333}{\log 0.1} \cdot \left(3 \cdot \log \left(\mathsf{hypot}\left(re, im\right)\right)\right)
\end{array}
Initial program 49.3%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.0%
log-prod99.0%
pow299.0%
div-inv98.6%
exp-to-pow98.7%
div-inv98.5%
exp-to-pow98.5%
Applied egg-rr98.5%
log-pow98.5%
distribute-lft1-in98.5%
metadata-eval98.5%
*-commutative98.5%
Simplified98.5%
pow1/398.1%
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-u76.0%
expm1-udef76.0%
log-pow76.0%
associate-*l*76.0%
Applied egg-rr76.0%
expm1-def76.1%
expm1-log1p99.4%
*-commutative99.4%
Simplified99.4%
Final simplification99.4%
(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 49.3%
hypot-def99.1%
Simplified99.1%
Final simplification99.1%
(FPCore (re im) :precision binary64 (* (/ -0.3333333333333333 (log 0.1)) (* 3.0 (log im))))
double code(double re, double im) {
return (-0.3333333333333333 / log(0.1)) * (3.0 * log(im));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = ((-0.3333333333333333d0) / log(0.1d0)) * (3.0d0 * log(im))
end function
public static double code(double re, double im) {
return (-0.3333333333333333 / Math.log(0.1)) * (3.0 * Math.log(im));
}
def code(re, im): return (-0.3333333333333333 / math.log(0.1)) * (3.0 * math.log(im))
function code(re, im) return Float64(Float64(-0.3333333333333333 / log(0.1)) * Float64(3.0 * log(im))) end
function tmp = code(re, im) tmp = (-0.3333333333333333 / log(0.1)) * (3.0 * log(im)); end
code[re_, im_] := N[(N[(-0.3333333333333333 / N[Log[0.1], $MachinePrecision]), $MachinePrecision] * N[(3.0 * N[Log[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{-0.3333333333333333}{\log 0.1} \cdot \left(3 \cdot \log im\right)
\end{array}
Initial program 49.3%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.0%
log-prod99.0%
pow299.0%
div-inv98.6%
exp-to-pow98.7%
div-inv98.5%
exp-to-pow98.5%
Applied egg-rr98.5%
log-pow98.5%
distribute-lft1-in98.5%
metadata-eval98.5%
*-commutative98.5%
Simplified98.5%
pow1/398.1%
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-u76.0%
expm1-udef76.0%
log-pow76.0%
associate-*l*76.0%
Applied egg-rr76.0%
expm1-def76.1%
expm1-log1p99.4%
*-commutative99.4%
Simplified99.4%
Taylor expanded in re around 0 29.4%
*-commutative29.4%
Simplified29.4%
Final simplification29.4%
(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 49.3%
hypot-def99.1%
Simplified99.1%
Taylor expanded in re around 0 29.4%
Final simplification29.4%
herbie shell --seed 2024031
(FPCore (re im)
:name "math.log10 on complex, real part"
:precision binary64
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))