math.log10 on complex, imaginary part

Percentage Accurate: 98.7% → 99.5%

Time: 30.9s

Alternatives: 4

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \end{array} \]

FPCore

(FPCore (re im) :precision binary64 (/ (atan2 im re) (log 10.0)))

C

double code(double re, double im) {
	return atan2(im, re) / log(10.0);
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = atan2(im, re) / log(10.0d0)
end function

Java

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

Python

def code(re, im):
	return math.atan2(im, re) / math.log(10.0)

Julia

function code(re, im)
	return Float64(atan(im, re) / log(10.0))
end

MATLAB

function tmp = code(re, im)
	tmp = atan2(im, re) / log(10.0);
end

Wolfram

code[re_, im_] := N[(N[ArcTan[im / re], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]

Initial Program: 98.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \end{array} \]

FPCore

(FPCore (re im) :precision binary64 (/ (atan2 im re) (log 10.0)))

C

double code(double re, double im) {
	return atan2(im, re) / log(10.0);
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = atan2(im, re) / log(10.0d0)
end function

Java

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

Python

def code(re, im):
	return math.atan2(im, re) / math.log(10.0)

Julia

function code(re, im)
	return Float64(atan(im, re) / log(10.0))
end

MATLAB

function tmp = code(re, im)
	tmp = atan2(im, re) / log(10.0);
end

Wolfram

code[re_, im_] := N[(N[ArcTan[im / re], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.5% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \frac{{\log 0.1}^{-1}}{\frac{-1}{\tan^{-1}_* \frac{im}{re}}} \end{array} \]

FPCore

(FPCore (re im)
 :precision binary64
 (/ (pow (log 0.1) -1.0) (/ -1.0 (atan2 im re))))

C

double code(double re, double im) {
	return pow(log(0.1), -1.0) / (-1.0 / atan2(im, re));
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = (log(0.1d0) ** (-1.0d0)) / ((-1.0d0) / atan2(im, re))
end function

Java

public static double code(double re, double im) {
	return Math.pow(Math.log(0.1), -1.0) / (-1.0 / Math.atan2(im, re));
}

Python

def code(re, im):
	return math.pow(math.log(0.1), -1.0) / (-1.0 / math.atan2(im, re))

Julia

function code(re, im)
	return Float64((log(0.1) ^ -1.0) / Float64(-1.0 / atan(im, re)))
end

MATLAB

function tmp = code(re, im)
	tmp = (log(0.1) ^ -1.0) / (-1.0 / atan2(im, re));
end

Wolfram

code[re_, im_] := N[(N[Power[N[Log[0.1], $MachinePrecision], -1.0], $MachinePrecision] / N[(-1.0 / N[ArcTan[im / re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.7%

   \[\frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-/.f64 N/A

      \[\leadsto \color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   2. frac-2neg N/A

      \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}{\mathsf{neg}\left(\log 10\right)}} \]

   3. clear-num N/A

      \[\leadsto \color{blue}{\frac{1}{\frac{\mathsf{neg}\left(\log 10\right)}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}}} \]

   4. div-inv N/A

      \[\leadsto \frac{1}{\color{blue}{\left(\mathsf{neg}\left(\log 10\right)\right) \cdot \frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}}} \]

   5. associate-/r* N/A

      \[\leadsto \color{blue}{\frac{\frac{1}{\mathsf{neg}\left(\log 10\right)}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}}} \]

   6. lower-/.f64 N/A

      \[\leadsto \color{blue}{\frac{\frac{1}{\mathsf{neg}\left(\log 10\right)}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}}} \]

   7. inv-pow N/A

      \[\leadsto \frac{\color{blue}{{\left(\mathsf{neg}\left(\log 10\right)\right)}^{-1}}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   8. lower-pow.f64 N/A

      \[\leadsto \frac{\color{blue}{{\left(\mathsf{neg}\left(\log 10\right)\right)}^{-1}}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   9. lift-log.f64 N/A

      \[\leadsto \frac{{\left(\mathsf{neg}\left(\color{blue}{\log 10}\right)\right)}^{-1}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   10. neg-log N/A

       \[\leadsto \frac{{\color{blue}{\log \left(\frac{1}{10}\right)}}^{-1}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   11. lower-log.f64 N/A

       \[\leadsto \frac{{\color{blue}{\log \left(\frac{1}{10}\right)}}^{-1}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   12. metadata-eval N/A

       \[\leadsto \frac{{\log \color{blue}{\frac{1}{10}}}^{-1}}{\frac{1}{\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)}} \]

   13. frac-2neg N/A

       \[\leadsto \frac{{\log \frac{1}{10}}^{-1}}{\color{blue}{\frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(\left(\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)\right)\right)}}} \]

   14. metadata-eval N/A

       \[\leadsto \frac{{\log \frac{1}{10}}^{-1}}{\frac{\color{blue}{-1}}{\mathsf{neg}\left(\left(\mathsf{neg}\left(\tan^{-1}_* \frac{im}{re}\right)\right)\right)}} \]

   15. remove-double-neg N/A

       \[\leadsto \frac{{\log \frac{1}{10}}^{-1}}{\frac{-1}{\color{blue}{\tan^{-1}_* \frac{im}{re}}}} \]

   16. lower-/.f64 99.7

       \[\leadsto \frac{{\log 0.1}^{-1}}{\color{blue}{\frac{-1}{\tan^{-1}_* \frac{im}{re}}}} \]

4. Applied rewrites 99.7%

   \[\leadsto \color{blue}{\frac{{\log 0.1}^{-1}}{\frac{-1}{\tan^{-1}_* \frac{im}{re}}}} \]
5. Add Preprocessing

Alternative 2: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\tan^{-1}_* \frac{im}{re}}{-\log 0.1} \end{array} \]

FPCore

(FPCore (re im) :precision binary64 (/ (atan2 im re) (- (log 0.1))))

C

double code(double re, double im) {
	return atan2(im, re) / -log(0.1);
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = atan2(im, re) / -log(0.1d0)
end function

Java

public static double code(double re, double im) {
	return Math.atan2(im, re) / -Math.log(0.1);
}

Python

def code(re, im):
	return math.atan2(im, re) / -math.log(0.1)

Julia

function code(re, im)
	return Float64(atan(im, re) / Float64(-log(0.1)))
end

MATLAB

function tmp = code(re, im)
	tmp = atan2(im, re) / -log(0.1);
end

Wolfram

code[re_, im_] := N[(N[ArcTan[im / re], $MachinePrecision] / (-N[Log[0.1], $MachinePrecision])), $MachinePrecision]

Derivation

1. Initial program 98.7%

   \[\frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. remove-double-neg N/A

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{\color{blue}{\mathsf{neg}\left(\left(\mathsf{neg}\left(\log 10\right)\right)\right)}} \]

   2. lower-neg.f64 N/A

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{\color{blue}{-\left(\mathsf{neg}\left(\log 10\right)\right)}} \]

   3. lift-log.f64 N/A

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{-\left(\mathsf{neg}\left(\color{blue}{\log 10}\right)\right)} \]

   4. neg-log N/A

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{-\color{blue}{\log \left(\frac{1}{10}\right)}} \]

   5. lower-log.f64 N/A

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{-\color{blue}{\log \left(\frac{1}{10}\right)}} \]

   6. metadata-eval 99.7

      \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{-\log \color{blue}{0.1}} \]

4. Applied rewrites 99.7%

   \[\leadsto \frac{\tan^{-1}_* \frac{im}{re}}{\color{blue}{-\log 0.1}} \]
5. Add Preprocessing

Alternative 3: 98.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \end{array} \]

FPCore

(FPCore (re im) :precision binary64 (/ (atan2 im re) (log 10.0)))

C

double code(double re, double im) {
	return atan2(im, re) / log(10.0);
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = atan2(im, re) / log(10.0d0)
end function

Java

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

Python

def code(re, im):
	return math.atan2(im, re) / math.log(10.0)

Julia

function code(re, im)
	return Float64(atan(im, re) / log(10.0))
end

MATLAB

function tmp = code(re, im)
	tmp = atan2(im, re) / log(10.0);
end

Wolfram

code[re_, im_] := N[(N[ArcTan[im / re], $MachinePrecision] / N[Log[10.0], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 98.7%

   \[\frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 4: 23.4% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \tan^{-1}_* \frac{im}{re} \end{array} \]

FPCore

(FPCore (re im) :precision binary64 (atan2 im re))

C

double code(double re, double im) {
	return atan2(im, re);
}

Fortran

real(8) function code(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    code = atan2(im, re)
end function

Java

public static double code(double re, double im) {
	return Math.atan2(im, re);
}

Python

def code(re, im):
	return math.atan2(im, re)

Julia

function code(re, im)
	return atan(im, re)
end

MATLAB

function tmp = code(re, im)
	tmp = atan2(im, re);
end

Wolfram

code[re_, im_] := N[ArcTan[im / re], $MachinePrecision]

Derivation

1. Initial program 98.7%

   \[\frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-/.f64 N/A

      \[\leadsto \color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   2. clear-num N/A

      \[\leadsto \color{blue}{\frac{1}{\frac{\log 10}{\tan^{-1}_* \frac{im}{re}}}} \]

   3. associate-/r/ N/A

      \[\leadsto \color{blue}{\frac{1}{\log 10} \cdot \tan^{-1}_* \frac{im}{re}} \]

   4. inv-pow N/A

      \[\leadsto \color{blue}{{\log 10}^{-1}} \cdot \tan^{-1}_* \frac{im}{re} \]

   5. sqr-pow N/A

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

   6. associate-*l* N/A

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

   7. lower-*.f64 N/A

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

   8. lower-pow.f64 N/A

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

   9. metadata-eval N/A

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

   10. lower-*.f64 N/A

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

   11. lower-pow.f64 N/A

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

   12. metadata-eval 98.8

       \[\leadsto {\log 10}^{-0.5} \cdot \left({\log 10}^{\color{blue}{-0.5}} \cdot \tan^{-1}_* \frac{im}{re}\right) \]

4. Applied rewrites 98.8%

   \[\leadsto \color{blue}{{\log 10}^{-0.5} \cdot \left({\log 10}^{-0.5} \cdot \tan^{-1}_* \frac{im}{re}\right)} \]
5. Step-by-step derivation

   1. lift-*.f64 N/A

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

   2. lift-*.f64 N/A

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

   3. associate-*r* N/A

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

   4. lift-pow.f64 N/A

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

   5. lift-pow.f64 N/A

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

   6. pow-prod-up N/A

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

   7. metadata-eval N/A

      \[\leadsto {\log 10}^{\color{blue}{-1}} \cdot \tan^{-1}_* \frac{im}{re} \]

   8. inv-pow N/A

      \[\leadsto \color{blue}{\frac{1}{\log 10}} \cdot \tan^{-1}_* \frac{im}{re} \]

   9. *-commutative N/A

      \[\leadsto \color{blue}{\tan^{-1}_* \frac{im}{re} \cdot \frac{1}{\log 10}} \]

   10. div-inv N/A

       \[\leadsto \color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   11. lift-/.f64 98.7

       \[\leadsto \color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   12. rem-square-sqrt N/A

       \[\leadsto \color{blue}{\sqrt{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \cdot \sqrt{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}}} \]

   13. sqrt-unprod N/A

       \[\leadsto \color{blue}{\sqrt{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10} \cdot \frac{\tan^{-1}_* \frac{im}{re}}{\log 10}}} \]

   14. lift-/.f64 N/A

       \[\leadsto \sqrt{\color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \cdot \frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   15. div-inv N/A

       \[\leadsto \sqrt{\color{blue}{\left(\tan^{-1}_* \frac{im}{re} \cdot \frac{1}{\log 10}\right)} \cdot \frac{\tan^{-1}_* \frac{im}{re}}{\log 10}} \]

   16. lift-/.f64 N/A

       \[\leadsto \sqrt{\left(\tan^{-1}_* \frac{im}{re} \cdot \frac{1}{\log 10}\right) \cdot \color{blue}{\frac{\tan^{-1}_* \frac{im}{re}}{\log 10}}} \]

   17. div-inv N/A

       \[\leadsto \sqrt{\left(\tan^{-1}_* \frac{im}{re} \cdot \frac{1}{\log 10}\right) \cdot \color{blue}{\left(\tan^{-1}_* \frac{im}{re} \cdot \frac{1}{\log 10}\right)}} \]

   18. swap-sqr N/A

       \[\leadsto \sqrt{\color{blue}{\left(\tan^{-1}_* \frac{im}{re} \cdot \tan^{-1}_* \frac{im}{re}\right) \cdot \left(\frac{1}{\log 10} \cdot \frac{1}{\log 10}\right)}} \]

   19. unpow2 N/A

       \[\leadsto \sqrt{\color{blue}{{\tan^{-1}_* \frac{im}{re}}^{2}} \cdot \left(\frac{1}{\log 10} \cdot \frac{1}{\log 10}\right)} \]

   20. lift-pow.f64 N/A

       \[\leadsto \sqrt{\color{blue}{{\tan^{-1}_* \frac{im}{re}}^{2}} \cdot \left(\frac{1}{\log 10} \cdot \frac{1}{\log 10}\right)} \]

6. Applied rewrites 98.8%

   \[\leadsto \color{blue}{\tan^{-1}_* \frac{im}{re} \cdot \sqrt{{\log 10}^{-2}}} \]

8. Applied rewrites 24.1%

   \[\leadsto \color{blue}{\tan^{-1}_* \frac{im}{re}} \]
9. Add Preprocessing

Reproduce

herbie shell --seed 2024268 
(FPCore (re im)
  :name "math.log10 on complex, imaginary part"
  :precision binary64
  (/ (atan2 im re) (log 10.0)))