math.log10 on complex, real part

Average Error: 32.1 → 7.2

Time: 55.9s

Precision: binary64

Cost: 26952

\[ \begin{array}{c}[re, im] = \mathsf{sort}([re, im])\\ \end{array} \]

Math

\[\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10} \]

↓

\[\begin{array}{l} \mathbf{if}\;re \leq -4.4 \cdot 10^{+77}:\\ \;\;\;\;\frac{\frac{\log \left(-re\right)}{\log 10} \cdot 2}{\frac{1}{\log 10} \cdot \left(\log 10 \cdot 2\right)}\\ \mathbf{elif}\;re \leq -1.02 \cdot 10^{-157}:\\ \;\;\;\;\frac{\frac{\log \left(re \cdot re + im \cdot im\right) \cdot 4}{\log 10}}{\log 10 \cdot \frac{8}{\log 10}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im \cdot 3}{\log 10 \cdot 4} - \frac{\log im}{\log 10 \cdot -4}\\ \end{array} \]

FPCore

(FPCore (re im)
 :precision binary64
 (/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))

↓

(FPCore (re im)
 :precision binary64
 (if (<= re -4.4e+77)
   (/
    (* (/ (log (- re)) (log 10.0)) 2.0)
    (* (/ 1.0 (log 10.0)) (* (log 10.0) 2.0)))
   (if (<= re -1.02e-157)
     (/
      (/ (* (log (+ (* re re) (* im im))) 4.0) (log 10.0))
      (* (log 10.0) (/ 8.0 (log 10.0))))
     (-
      (/ (* (log im) 3.0) (* (log 10.0) 4.0))
      (/ (log im) (* (log 10.0) -4.0))))))

C

double code(double re, double im) {
	return log(sqrt(((re * re) + (im * im)))) / log(10.0);
}

↓

double code(double re, double im) {
	double tmp;
	if (re <= -4.4e+77) {
		tmp = ((log(-re) / log(10.0)) * 2.0) / ((1.0 / log(10.0)) * (log(10.0) * 2.0));
	} else if (re <= -1.02e-157) {
		tmp = ((log(((re * re) + (im * im))) * 4.0) / log(10.0)) / (log(10.0) * (8.0 / log(10.0)));
	} else {
		tmp = ((log(im) * 3.0) / (log(10.0) * 4.0)) - (log(im) / (log(10.0) * -4.0));
	}
	return tmp;
}

Fortran

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

↓

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    real(8) :: tmp
    if (re <= (-4.4d+77)) then
        tmp = ((log(-re) / log(10.0d0)) * 2.0d0) / ((1.0d0 / log(10.0d0)) * (log(10.0d0) * 2.0d0))
    else if (re <= (-1.02d-157)) then
        tmp = ((log(((re * re) + (im * im))) * 4.0d0) / log(10.0d0)) / (log(10.0d0) * (8.0d0 / log(10.0d0)))
    else
        tmp = ((log(im) * 3.0d0) / (log(10.0d0) * 4.0d0)) - (log(im) / (log(10.0d0) * (-4.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double re, double im) {
	return Math.log(Math.sqrt(((re * re) + (im * im)))) / Math.log(10.0);
}

↓

public static double code(double re, double im) {
	double tmp;
	if (re <= -4.4e+77) {
		tmp = ((Math.log(-re) / Math.log(10.0)) * 2.0) / ((1.0 / Math.log(10.0)) * (Math.log(10.0) * 2.0));
	} else if (re <= -1.02e-157) {
		tmp = ((Math.log(((re * re) + (im * im))) * 4.0) / Math.log(10.0)) / (Math.log(10.0) * (8.0 / Math.log(10.0)));
	} else {
		tmp = ((Math.log(im) * 3.0) / (Math.log(10.0) * 4.0)) - (Math.log(im) / (Math.log(10.0) * -4.0));
	}
	return tmp;
}

Python

def code(re, im):
	return math.log(math.sqrt(((re * re) + (im * im)))) / math.log(10.0)

↓

def code(re, im):
	tmp = 0
	if re <= -4.4e+77:
		tmp = ((math.log(-re) / math.log(10.0)) * 2.0) / ((1.0 / math.log(10.0)) * (math.log(10.0) * 2.0))
	elif re <= -1.02e-157:
		tmp = ((math.log(((re * re) + (im * im))) * 4.0) / math.log(10.0)) / (math.log(10.0) * (8.0 / math.log(10.0)))
	else:
		tmp = ((math.log(im) * 3.0) / (math.log(10.0) * 4.0)) - (math.log(im) / (math.log(10.0) * -4.0))
	return tmp

Julia

function code(re, im)
	return Float64(log(sqrt(Float64(Float64(re * re) + Float64(im * im)))) / log(10.0))
end

↓

function code(re, im)
	tmp = 0.0
	if (re <= -4.4e+77)
		tmp = Float64(Float64(Float64(log(Float64(-re)) / log(10.0)) * 2.0) / Float64(Float64(1.0 / log(10.0)) * Float64(log(10.0) * 2.0)));
	elseif (re <= -1.02e-157)
		tmp = Float64(Float64(Float64(log(Float64(Float64(re * re) + Float64(im * im))) * 4.0) / log(10.0)) / Float64(log(10.0) * Float64(8.0 / log(10.0))));
	else
		tmp = Float64(Float64(Float64(log(im) * 3.0) / Float64(log(10.0) * 4.0)) - Float64(log(im) / Float64(log(10.0) * -4.0)));
	end
	return tmp
end

MATLAB

function tmp = code(re, im)
	tmp = log(sqrt(((re * re) + (im * im)))) / log(10.0);
end

↓

function tmp_2 = code(re, im)
	tmp = 0.0;
	if (re <= -4.4e+77)
		tmp = ((log(-re) / log(10.0)) * 2.0) / ((1.0 / log(10.0)) * (log(10.0) * 2.0));
	elseif (re <= -1.02e-157)
		tmp = ((log(((re * re) + (im * im))) * 4.0) / log(10.0)) / (log(10.0) * (8.0 / log(10.0)));
	else
		tmp = ((log(im) * 3.0) / (log(10.0) * 4.0)) - (log(im) / (log(10.0) * -4.0));
	end
	tmp_2 = tmp;
end

Wolfram

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]

↓

code[re_, im_] := If[LessEqual[re, -4.4e+77], N[(N[(N[(N[Log[(-re)], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision] / N[(N[(1.0 / N[Log[10.0], $MachinePrecision]), $MachinePrecision] * N[(N[Log[10.0], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[re, -1.02e-157], N[(N[(N[(N[Log[N[(N[(re * re), $MachinePrecision] + N[(im * im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 4.0), $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision] / N[(N[Log[10.0], $MachinePrecision] * N[(8.0 / N[Log[10.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Log[im], $MachinePrecision] * 3.0), $MachinePrecision] / N[(N[Log[10.0], $MachinePrecision] * 4.0), $MachinePrecision]), $MachinePrecision] - N[(N[Log[im], $MachinePrecision] / N[(N[Log[10.0], $MachinePrecision] * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if re < -4.4000000000000001e77

   1. Initial program 47.5

      \[\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10} \]

   2. Taylor expanded in re around -inf 6.2

      \[\leadsto \frac{\log \color{blue}{\left(-1 \cdot re\right)}}{\log 10} \]

   3. Simplified 6.2

      \[\leadsto \frac{\log \color{blue}{\left(-re\right)}}{\log 10} \]
      Proof

      [Start] 6.2	\[ \frac{\log \left(-1 \cdot re\right)}{\log 10} \]
      rational_best-simplify-1 [=>] 6.2	\[ \frac{\log \color{blue}{\left(re \cdot -1\right)}}{\log 10} \]
      rational_best-simplify-11 [<=] 6.2	\[ \frac{\log \color{blue}{\left(-re\right)}}{\log 10} \]

   4. Applied egg-rr 6.5

      \[\leadsto \color{blue}{\frac{\log \left(-re\right)}{\log 10 \cdot \log 10} \cdot \log 10} \]

   5. Applied egg-rr 6.1

      \[\leadsto \color{blue}{\frac{\frac{\log \left(-re\right)}{\log 10} \cdot 2}{\frac{1}{\log 10} \cdot \left(\log 10 \cdot 2\right)}} \]

   if -4.4000000000000001e77 < re < -1.0200000000000001e-157

   1. Initial program 11.3

      \[\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10} \]

   2. Applied egg-rr 11.6

      \[\leadsto \color{blue}{\frac{\log \left(re \cdot re + im \cdot im\right)}{\log 10 \cdot \log 10} \cdot \frac{1}{\frac{2}{\log 10}}} \]

   3. Applied egg-rr 11.2

      \[\leadsto \color{blue}{\frac{\frac{\log \left(re \cdot re + im \cdot im\right) \cdot 4}{\log 10}}{\log 10 \cdot \frac{8}{\log 10}}} \]

   if -1.0200000000000001e-157 < re

   1. Initial program 32.9

      \[\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10} \]

   2. Taylor expanded in re around 0 5.3

      \[\leadsto \frac{\log \color{blue}{im}}{\log 10} \]

   3. Applied egg-rr 5.4

      \[\leadsto \color{blue}{\frac{\log im \cdot 3}{\log 10 \cdot 4} - \frac{\log im}{\log 10 \cdot -4}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 7.2

   \[\leadsto \begin{array}{l} \mathbf{if}\;re \leq -4.4 \cdot 10^{+77}:\\ \;\;\;\;\frac{\frac{\log \left(-re\right)}{\log 10} \cdot 2}{\frac{1}{\log 10} \cdot \left(\log 10 \cdot 2\right)}\\ \mathbf{elif}\;re \leq -1.02 \cdot 10^{-157}:\\ \;\;\;\;\frac{\frac{\log \left(re \cdot re + im \cdot im\right) \cdot 4}{\log 10}}{\log 10 \cdot \frac{8}{\log 10}}\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im \cdot 3}{\log 10 \cdot 4} - \frac{\log im}{\log 10 \cdot -4}\\ \end{array} \]

Alternatives

Alternative 1
Error	7.3
Cost	26696

\[\begin{array}{l} \mathbf{if}\;re \leq -4.8 \cdot 10^{+77}:\\ \;\;\;\;\frac{\log \left(-re\right)}{\log 10}\\ \mathbf{elif}\;re \leq -7.2 \cdot 10^{-156}:\\ \;\;\;\;\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10}\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im \cdot 3}{\log 10 \cdot 4} - \frac{\log im}{\log 10 \cdot -4}\\ \end{array} \]

Alternative 2
Error	7.3
Cost	26696

\[\begin{array}{l} \mathbf{if}\;re \leq -5.5 \cdot 10^{+77}:\\ \;\;\;\;\frac{\frac{\log \left(-re\right)}{\log 10} \cdot 2}{\frac{1}{\log 10} \cdot \left(\log 10 \cdot 2\right)}\\ \mathbf{elif}\;re \leq -1 \cdot 10^{-160}:\\ \;\;\;\;\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10}\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im \cdot 3}{\log 10 \cdot 4} - \frac{\log im}{\log 10 \cdot -4}\\ \end{array} \]

Alternative 3
Error	7.3
Cost	20040

\[\begin{array}{l} \mathbf{if}\;re \leq -5.5 \cdot 10^{+77}:\\ \;\;\;\;\frac{\log \left(-re\right)}{\log 10}\\ \mathbf{elif}\;re \leq -5 \cdot 10^{-158}:\\ \;\;\;\;\frac{\log \left(\sqrt{re \cdot re + im \cdot im}\right)}{\log 10}\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im}{\log 10}\\ \end{array} \]

Alternative 4
Error	7.3
Cost	13768

\[\begin{array}{l} \mathbf{if}\;re \leq -5.5 \cdot 10^{+77}:\\ \;\;\;\;\frac{\log \left(-re\right)}{\log 10}\\ \mathbf{elif}\;re \leq -1.65 \cdot 10^{-158}:\\ \;\;\;\;\frac{\log \left(re \cdot re + im \cdot im\right)}{\log 10} \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{\log im}{\log 10}\\ \end{array} \]

Alternative 5
Error	11.2
Cost	13452

\[\begin{array}{l} t_0 := \frac{\log \left(-re\right)}{\log 10}\\ t_1 := \frac{\log im}{\log 10}\\ \mathbf{if}\;re \leq -1.3 \cdot 10^{-46}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;re \leq -8 \cdot 10^{-124}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;re \leq -6 \cdot 10^{-177}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \]

Alternative 6
Error	30.8
Cost	12992

\[\frac{\log im}{\log 10} \]

Reproduce

herbie shell --seed 2023099 
(FPCore (re im)
  :name "math.log10 on complex, real part"
  :precision binary64
  (/ (log (sqrt (+ (* re re) (* im im)))) (log 10.0)))