
(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 6 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 (* (* (/ -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(Float64(-0.3333333333333333 / log(0.1)) * 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[(N[(-0.3333333333333333 / N[Log[0.1], $MachinePrecision]), $MachinePrecision] * 3.0), $MachinePrecision] * N[Log[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\frac{-0.3333333333333333}{\log 0.1} \cdot 3\right) \cdot \log \left(\mathsf{hypot}\left(re, im\right)\right)
\end{array}
Initial program 52.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
hypot-def99.1%
Simplified99.1%
*-un-lft-identity99.1%
add-sqr-sqrt99.1%
times-frac99.2%
pow1/299.2%
pow-flip99.2%
metadata-eval99.2%
Applied egg-rr99.2%
metadata-eval99.2%
pow-flip99.2%
pow1/299.2%
times-frac99.1%
add-sqr-sqrt99.1%
associate-/l*99.1%
div-inv99.1%
associate-/r*98.6%
frac-2neg98.6%
metadata-eval98.6%
neg-log98.9%
metadata-eval98.9%
Applied egg-rr98.9%
associate-/r/98.9%
/-rgt-identity98.9%
associate-*l/99.0%
metadata-eval99.0%
associate-*r*99.1%
*-commutative99.1%
associate-*l/99.3%
*-commutative99.3%
associate-*r*99.6%
Applied egg-rr99.6%
Final simplification99.6%
(FPCore (re im) :precision binary64 (* 3.0 (* (/ -0.3333333333333333 (log 0.1)) (log (hypot re im)))))
double code(double re, double im) {
return 3.0 * ((-0.3333333333333333 / log(0.1)) * log(hypot(re, im)));
}
public static double code(double re, double im) {
return 3.0 * ((-0.3333333333333333 / Math.log(0.1)) * Math.log(Math.hypot(re, im)));
}
def code(re, im): return 3.0 * ((-0.3333333333333333 / math.log(0.1)) * math.log(math.hypot(re, im)))
function code(re, im) return Float64(3.0 * Float64(Float64(-0.3333333333333333 / log(0.1)) * log(hypot(re, im)))) end
function tmp = code(re, im) tmp = 3.0 * ((-0.3333333333333333 / log(0.1)) * log(hypot(re, im))); end
code[re_, im_] := N[(3.0 * N[(N[(-0.3333333333333333 / N[Log[0.1], $MachinePrecision]), $MachinePrecision] * N[Log[N[Sqrt[re ^ 2 + im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
3 \cdot \left(\frac{-0.3333333333333333}{\log 0.1} \cdot \log \left(\mathsf{hypot}\left(re, im\right)\right)\right)
\end{array}
Initial program 52.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.0%
log-prod99.0%
pow299.0%
div-inv98.7%
exp-to-pow98.7%
div-inv98.6%
exp-to-pow98.5%
Applied egg-rr98.5%
log-pow98.5%
distribute-lft1-in98.5%
metadata-eval98.5%
*-commutative98.5%
Simplified98.5%
pow1/398.2%
pow-pow98.5%
frac-2neg98.5%
metadata-eval98.5%
neg-log99.4%
metadata-eval99.4%
Applied egg-rr99.4%
associate-*l/99.4%
metadata-eval99.4%
Simplified99.4%
expm1-log1p-u72.9%
expm1-udef72.9%
log-pow72.9%
Applied egg-rr72.9%
expm1-def72.9%
expm1-log1p99.3%
*-commutative99.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.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
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 52.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
hypot-def99.1%
Simplified99.1%
add-log-exp99.1%
add-cube-cbrt99.0%
log-prod99.0%
pow299.0%
div-inv98.7%
exp-to-pow98.7%
div-inv98.6%
exp-to-pow98.5%
Applied egg-rr98.5%
log-pow98.5%
distribute-lft1-in98.5%
metadata-eval98.5%
*-commutative98.5%
Simplified98.5%
pow1/398.2%
pow-pow98.5%
frac-2neg98.5%
metadata-eval98.5%
neg-log99.4%
metadata-eval99.4%
Applied egg-rr99.4%
associate-*l/99.4%
metadata-eval99.4%
Simplified99.4%
expm1-log1p-u72.9%
expm1-udef72.9%
log-pow72.9%
Applied egg-rr72.9%
expm1-def72.9%
expm1-log1p99.3%
associate-*l*99.3%
Simplified99.3%
Taylor expanded in re around 0 29.3%
*-commutative29.3%
Simplified29.3%
Final simplification29.3%
(FPCore (re im) :precision binary64 (/ 1.0 (/ (log 10.0) (log im))))
double code(double re, double im) {
return 1.0 / (log(10.0) / log(im));
}
real(8) function code(re, im)
real(8), intent (in) :: re
real(8), intent (in) :: im
code = 1.0d0 / (log(10.0d0) / log(im))
end function
public static double code(double re, double im) {
return 1.0 / (Math.log(10.0) / Math.log(im));
}
def code(re, im): return 1.0 / (math.log(10.0) / math.log(im))
function code(re, im) return Float64(1.0 / Float64(log(10.0) / log(im))) end
function tmp = code(re, im) tmp = 1.0 / (log(10.0) / log(im)); end
code[re_, im_] := N[(1.0 / N[(N[Log[10.0], $MachinePrecision] / N[Log[im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{1}{\frac{\log 10}{\log im}}
\end{array}
Initial program 52.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
hypot-def99.1%
Simplified99.1%
Taylor expanded in re around 0 29.3%
clear-num29.3%
inv-pow29.3%
Applied egg-rr29.3%
unpow-129.3%
Simplified29.3%
Final simplification29.3%
(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.1%
+-commutative52.1%
+-commutative52.1%
sqr-neg52.1%
sqr-neg52.1%
+-commutative52.1%
+-commutative52.1%
hypot-def99.1%
Simplified99.1%
Taylor expanded in re around 0 29.3%
Final simplification29.3%
herbie shell --seed 2023334
(FPCore (re im)
:name "math.log10 on complex, real part"
:precision binary64
(/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))