bug329 (missed optimization)

Percentage Accurate: 100.0% → 100.0%

Time: 3.1s

Alternatives: 2

Speedup: 1.0×

Specification

\[x \geq 0\]

Math

\[\begin{array}{l} \\ \tan^{-1} \left(\frac{y}{x}\right) \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (atan (/ y x)))

C

double code(double x, double y) {
	return atan((y / x));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = atan((y / x))
end function

Java

public static double code(double x, double y) {
	return Math.atan((y / x));
}

Python

def code(x, y):
	return math.atan((y / x))

Julia

function code(x, y)
	return atan(Float64(y / x))
end

MATLAB

function tmp = code(x, y)
	tmp = atan((y / x));
end

Wolfram

code[x_, y_] := N[ArcTan[N[(y / x), $MachinePrecision]], $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \tan^{-1} \left(\frac{y}{x}\right) \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (atan (/ y x)))

C

double code(double x, double y) {
	return atan((y / x));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = atan((y / x))
end function

Java

public static double code(double x, double y) {
	return Math.atan((y / x));
}

Python

def code(x, y):
	return math.atan((y / x))

Julia

function code(x, y)
	return atan(Float64(y / x))
end

MATLAB

function tmp = code(x, y)
	tmp = atan((y / x));
end

Wolfram

code[x_, y_] := N[ArcTan[N[(y / x), $MachinePrecision]], $MachinePrecision]

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \tan^{-1} \left(\frac{y}{x}\right) \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (atan (/ y x)))

C

double code(double x, double y) {
	return atan((y / x));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = atan((y / x))
end function

Java

public static double code(double x, double y) {
	return Math.atan((y / x));
}

Python

def code(x, y):
	return math.atan((y / x))

Julia

function code(x, y)
	return atan(Float64(y / x))
end

MATLAB

function tmp = code(x, y)
	tmp = atan((y / x));
end

Wolfram

code[x_, y_] := N[ArcTan[N[(y / x), $MachinePrecision]], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\tan^{-1} \left(\frac{y}{x}\right) \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 39.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \tan^{-1} y \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (atan y))

C

double code(double x, double y) {
	return atan(y);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = atan(y)
end function

Java

public static double code(double x, double y) {
	return Math.atan(y);
}

Python

def code(x, y):
	return math.atan(y)

Julia

function code(x, y)
	return atan(y)
end

MATLAB

function tmp = code(x, y)
	tmp = atan(y);
end

Wolfram

code[x_, y_] := N[ArcTan[y], $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\tan^{-1} \left(\frac{y}{x}\right) \]
2. Add Preprocessing
3. Step-by-step derivation

   1. clear-num N/A

      \[\leadsto \mathsf{atan.f64}\left(\left(\frac{1}{\frac{x}{y}}\right)\right) \]

   2. associate-/r/ N/A

      \[\leadsto \mathsf{atan.f64}\left(\left(\frac{1}{x} \cdot y\right)\right) \]

   3. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\left(\frac{1}{x}\right), y\right)\right) \]

   4. /-lowering-/.f64 99.9%

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\mathsf{/.f64}\left(1, x\right), y\right)\right) \]

4. Applied egg-rr 99.9%

   \[\leadsto \tan^{-1} \color{blue}{\left(\frac{1}{x} \cdot y\right)} \]
5. Step-by-step derivation

   1. inv-pow N/A

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\left({x}^{-1}\right), y\right)\right) \]

   2. metadata-eval N/A

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\left({x}^{\left(\frac{-1}{2} \cdot 2\right)}\right), y\right)\right) \]

   3. pow-pow N/A

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\left({\left({x}^{\frac{-1}{2}}\right)}^{2}\right), y\right)\right) \]

   4. pow-lowering-pow.f64 N/A

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\mathsf{pow.f64}\left(\left({x}^{\frac{-1}{2}}\right), 2\right), y\right)\right) \]

   5. pow-lowering-pow.f64 99.7%

      \[\leadsto \mathsf{atan.f64}\left(\mathsf{*.f64}\left(\mathsf{pow.f64}\left(\mathsf{pow.f64}\left(x, \frac{-1}{2}\right), 2\right), y\right)\right) \]

6. Applied egg-rr 99.7%

   \[\leadsto \tan^{-1} \left(\color{blue}{{\left({x}^{-0.5}\right)}^{2}} \cdot y\right) \]

8. Applied egg-rr 38.5%

   \[\leadsto \color{blue}{\tan^{-1} y} \]
9. Add Preprocessing

Developer Target 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (atan2 y x))

C

double code(double x, double y) {
	return atan2(y, x);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = atan2(y, x)
end function

Java

public static double code(double x, double y) {
	return Math.atan2(y, x);
}

Python

def code(x, y):
	return math.atan2(y, x)

Julia

function code(x, y)
	return atan(y, x)
end

MATLAB

function tmp = code(x, y)
	tmp = atan2(y, x);
end

Wolfram

code[x_, y_] := N[ArcTan[y / x], $MachinePrecision]

Reproduce

herbie shell --seed 2024158 
(FPCore (x y)
  :name "bug329 (missed optimization)"
  :precision binary64
  :pre (>= x 0.0)

  :alt
  (! :herbie-platform default (atan2 y x))

  (atan (/ y x)))