_divideComplex, imaginary part

Percentage Accurate: 61.8% → 58.5%

Time: 10.6s

Alternatives: 4

Speedup: N/A×

Specification

Math

\[\begin{array}{l} \\ \frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}

Fortran

real(8) function code(x_46re, x_46im, y_46re, y_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8), intent (in) :: y_46re
    real(8), intent (in) :: y_46im
    code = ((x_46im * y_46re) - (x_46re * y_46im)) / ((y_46re * y_46re) + (y_46im * y_46im))
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(Float64(Float64(x_46_im * y_46_re) - Float64(x_46_re * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im)))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(N[(x$46$im * y$46$re), $MachinePrecision] - N[(x$46$re * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 61.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}

Fortran

real(8) function code(x_46re, x_46im, y_46re, y_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8), intent (in) :: y_46re
    real(8), intent (in) :: y_46im
    code = ((x_46im * y_46re) - (x_46re * y_46im)) / ((y_46re * y_46re) + (y_46im * y_46im))
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(Float64(Float64(x_46_im * y_46_re) - Float64(x_46_re * y_46_im)) / Float64(Float64(y_46_re * y_46_re) + Float64(y_46_im * y_46_im)))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = ((x_46_im * y_46_re) - (x_46_re * y_46_im)) / ((y_46_re * y_46_re) + (y_46_im * y_46_im));
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(N[(x$46$im * y$46$re), $MachinePrecision] - N[(x$46$re * y$46$im), $MachinePrecision]), $MachinePrecision] / N[(N[(y$46$re * y$46$re), $MachinePrecision] + N[(y$46$im * y$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 58.5% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot x.im}{\mathsf{hypot}\left(y.re, y.im\right)} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (/ (* (/ y.re (hypot y.re y.im)) x.im) (hypot y.re y.im)))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((y_46_re / hypot(y_46_re, y_46_im)) * x_46_im) / hypot(y_46_re, y_46_im);
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return ((y_46_re / Math.hypot(y_46_re, y_46_im)) * x_46_im) / Math.hypot(y_46_re, y_46_im);
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return ((y_46_re / math.hypot(y_46_re, y_46_im)) * x_46_im) / math.hypot(y_46_re, y_46_im)

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(Float64(Float64(y_46_re / hypot(y_46_re, y_46_im)) * x_46_im) / hypot(y_46_re, y_46_im))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = ((y_46_re / hypot(y_46_re, y_46_im)) * x_46_im) / hypot(y_46_re, y_46_im);
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(N[(y$46$re / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision] * x$46$im), $MachinePrecision] / N[Sqrt[y$46$re ^ 2 + y$46$im ^ 2], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 58.2%

   \[\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \]
2. Add Preprocessing

3. Taylor expanded in x.im around inf 37.5%

   \[\leadsto \color{blue}{\frac{x.im \cdot y.re}{{y.im}^{2} + {y.re}^{2}}} \]
4. Step-by-step derivation

   1. associate-/l* 40.2%

      \[\leadsto \color{blue}{\frac{x.im}{\frac{{y.im}^{2} + {y.re}^{2}}{y.re}}} \]

   2. unpow2 40.2%

      \[\leadsto \frac{x.im}{\frac{\color{blue}{y.im \cdot y.im} + {y.re}^{2}}{y.re}} \]

   3. fma-udef 40.2%

      \[\leadsto \frac{x.im}{\frac{\color{blue}{\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)}}{y.re}} \]

5. Simplified 40.2%

   \[\leadsto \color{blue}{\frac{x.im}{\frac{\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)}{y.re}}} \]
6. Step-by-step derivation

   1. associate-/l* 37.5%

      \[\leadsto \color{blue}{\frac{x.im \cdot y.re}{\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)}} \]

   2. *-commutative 37.5%

      \[\leadsto \frac{\color{blue}{y.re \cdot x.im}}{\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)} \]

   3. pow1 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{\color{blue}{{\left(\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)\right)}^{1}}} \]

   4. metadata-eval 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{{\left(\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)\right)}^{\color{blue}{\left(\frac{2}{2}\right)}}} \]

   5. sqrt-pow2 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{\color{blue}{{\left(\sqrt{\mathsf{fma}\left(y.im, y.im, {y.re}^{2}\right)}\right)}^{2}}} \]

   6. fma-udef 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{{\left(\sqrt{\color{blue}{y.im \cdot y.im + {y.re}^{2}}}\right)}^{2}} \]

   7. +-commutative 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{{\left(\sqrt{\color{blue}{{y.re}^{2} + y.im \cdot y.im}}\right)}^{2}} \]

   8. pow2 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{{\left(\sqrt{\color{blue}{y.re \cdot y.re} + y.im \cdot y.im}\right)}^{2}} \]

   9. hypot-udef 37.5%

      \[\leadsto \frac{y.re \cdot x.im}{{\color{blue}{\left(\mathsf{hypot}\left(y.re, y.im\right)\right)}}^{2}} \]

   10. unpow2 37.5%

       \[\leadsto \frac{y.re \cdot x.im}{\color{blue}{\mathsf{hypot}\left(y.re, y.im\right) \cdot \mathsf{hypot}\left(y.re, y.im\right)}} \]

   11. times-frac 58.3%

       \[\leadsto \color{blue}{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{x.im}{\mathsf{hypot}\left(y.re, y.im\right)}} \]

7. Applied egg-rr 58.3%

   \[\leadsto \color{blue}{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{x.im}{\mathsf{hypot}\left(y.re, y.im\right)}} \]
8. Step-by-step derivation

   1. associate-*r/ 59.7%

      \[\leadsto \color{blue}{\frac{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot x.im}{\mathsf{hypot}\left(y.re, y.im\right)}} \]

9. Simplified 59.7%

   \[\leadsto \color{blue}{\frac{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot x.im}{\mathsf{hypot}\left(y.re, y.im\right)}} \]

10. Final simplification 59.7%

    \[\leadsto \frac{\frac{y.re}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot x.im}{\mathsf{hypot}\left(y.re, y.im\right)} \]
11. Add Preprocessing

Alternative 2: 48.4% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \frac{x.im}{y.re} - y.im \cdot \frac{x.re}{{y.re}^{2}} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (- (/ x.im y.re) (* y.im (/ x.re (pow y.re 2.0)))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return (x_46_im / y_46_re) - (y_46_im * (x_46_re / pow(y_46_re, 2.0)));
}

Fortran

real(8) function code(x_46re, x_46im, y_46re, y_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8), intent (in) :: y_46re
    real(8), intent (in) :: y_46im
    code = (x_46im / y_46re) - (y_46im * (x_46re / (y_46re ** 2.0d0)))
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return (x_46_im / y_46_re) - (y_46_im * (x_46_re / Math.pow(y_46_re, 2.0)));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return (x_46_im / y_46_re) - (y_46_im * (x_46_re / math.pow(y_46_re, 2.0)))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(Float64(x_46_im / y_46_re) - Float64(y_46_im * Float64(x_46_re / (y_46_re ^ 2.0))))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = (x_46_im / y_46_re) - (y_46_im * (x_46_re / (y_46_re ^ 2.0)));
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[(x$46$im / y$46$re), $MachinePrecision] - N[(y$46$im * N[(x$46$re / N[Power[y$46$re, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 58.2%

   \[\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \]
2. Add Preprocessing

3. Taylor expanded in y.re around inf 50.7%

   \[\leadsto \color{blue}{-1 \cdot \frac{x.re \cdot y.im}{{y.re}^{2}} + \frac{x.im}{y.re}} \]
4. Step-by-step derivation

   1. +-commutative 50.7%

      \[\leadsto \color{blue}{\frac{x.im}{y.re} + -1 \cdot \frac{x.re \cdot y.im}{{y.re}^{2}}} \]

   2. mul-1-neg 50.7%

      \[\leadsto \frac{x.im}{y.re} + \color{blue}{\left(-\frac{x.re \cdot y.im}{{y.re}^{2}}\right)} \]

   3. unsub-neg 50.7%

      \[\leadsto \color{blue}{\frac{x.im}{y.re} - \frac{x.re \cdot y.im}{{y.re}^{2}}} \]

   4. associate-/l* 52.5%

      \[\leadsto \frac{x.im}{y.re} - \color{blue}{\frac{x.re}{\frac{{y.re}^{2}}{y.im}}} \]

   5. associate-/r/ 49.9%

      \[\leadsto \frac{x.im}{y.re} - \color{blue}{\frac{x.re}{{y.re}^{2}} \cdot y.im} \]

5. Simplified 49.9%

   \[\leadsto \color{blue}{\frac{x.im}{y.re} - \frac{x.re}{{y.re}^{2}} \cdot y.im} \]

6. Final simplification 49.9%

   \[\leadsto \frac{x.im}{y.re} - y.im \cdot \frac{x.re}{{y.re}^{2}} \]
7. Add Preprocessing

Alternative 3: 9.5% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ \frac{x.im}{y.im} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im) :precision binary64 (/ x.im y.im))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return x_46_im / y_46_im;
}

Fortran

real(8) function code(x_46re, x_46im, y_46re, y_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8), intent (in) :: y_46re
    real(8), intent (in) :: y_46im
    code = x_46im / y_46im
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return x_46_im / y_46_im;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return x_46_im / y_46_im

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(x_46_im / y_46_im)
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = x_46_im / y_46_im;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(x$46$im / y$46$im), $MachinePrecision]

Derivation

1. Initial program 58.2%

   \[\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. fma-neg 58.2%

      \[\leadsto \frac{\color{blue}{\mathsf{fma}\left(x.im, y.re, -x.re \cdot y.im\right)}}{y.re \cdot y.re + y.im \cdot y.im} \]

   2. *-commutative 58.2%

      \[\leadsto \frac{\mathsf{fma}\left(x.im, y.re, -\color{blue}{y.im \cdot x.re}\right)}{y.re \cdot y.re + y.im \cdot y.im} \]

   3. distribute-rgt-neg-out 58.2%

      \[\leadsto \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{y.im \cdot \left(-x.re\right)}\right)}{y.re \cdot y.re + y.im \cdot y.im} \]

   4. *-un-lft-identity 58.2%

      \[\leadsto \frac{\color{blue}{1 \cdot \mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}}{y.re \cdot y.re + y.im \cdot y.im} \]

   5. fma-def 58.2%

      \[\leadsto \frac{1 \cdot \mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}{\color{blue}{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   6. add-sqr-sqrt 58.2%

      \[\leadsto \frac{1 \cdot \mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}{\color{blue}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)} \cdot \sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}}} \]

   7. times-frac 58.2%

      \[\leadsto \color{blue}{\frac{1}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \cdot \frac{\mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}}} \]

   8. fma-def 58.2%

      \[\leadsto \frac{1}{\sqrt{\color{blue}{y.re \cdot y.re + y.im \cdot y.im}}} \cdot \frac{\mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   9. hypot-def 58.2%

      \[\leadsto \frac{1}{\color{blue}{\mathsf{hypot}\left(y.re, y.im\right)}} \cdot \frac{\mathsf{fma}\left(x.im, y.re, y.im \cdot \left(-x.re\right)\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   10. *-commutative 58.2%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{\left(-x.re\right) \cdot y.im}\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   11. add-sqr-sqrt 30.8%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{\left(\sqrt{-x.re} \cdot \sqrt{-x.re}\right)} \cdot y.im\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   12. sqrt-unprod 38.9%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{\sqrt{\left(-x.re\right) \cdot \left(-x.re\right)}} \cdot y.im\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   13. sqr-neg 38.9%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \sqrt{\color{blue}{x.re \cdot x.re}} \cdot y.im\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   14. sqrt-unprod 16.8%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{\left(\sqrt{x.re} \cdot \sqrt{x.re}\right)} \cdot y.im\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   15. add-sqr-sqrt 36.0%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, \color{blue}{x.re} \cdot y.im\right)}{\sqrt{\mathsf{fma}\left(y.re, y.re, y.im \cdot y.im\right)}} \]

   16. fma-def 36.0%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, x.re \cdot y.im\right)}{\sqrt{\color{blue}{y.re \cdot y.re + y.im \cdot y.im}}} \]

   17. hypot-def 44.0%

       \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, x.re \cdot y.im\right)}{\color{blue}{\mathsf{hypot}\left(y.re, y.im\right)}} \]

4. Applied egg-rr 44.0%

   \[\leadsto \color{blue}{\frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \frac{\mathsf{fma}\left(x.im, y.re, x.re \cdot y.im\right)}{\mathsf{hypot}\left(y.re, y.im\right)}} \]

5. Taylor expanded in y.re around -inf 30.2%

   \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \color{blue}{\left(-1 \cdot x.im\right)} \]
6. Step-by-step derivation

   1. neg-mul-1 30.2%

      \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \color{blue}{\left(-x.im\right)} \]

7. Simplified 30.2%

   \[\leadsto \frac{1}{\mathsf{hypot}\left(y.re, y.im\right)} \cdot \color{blue}{\left(-x.im\right)} \]

8. Taylor expanded in y.im around -inf 8.5%

   \[\leadsto \color{blue}{\frac{x.im}{y.im}} \]

9. Final simplification 8.5%

   \[\leadsto \frac{x.im}{y.im} \]
10. Add Preprocessing

Alternative 4: 43.0% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ \frac{x.im}{y.re} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im) :precision binary64 (/ x.im y.re))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return x_46_im / y_46_re;
}

Fortran

real(8) function code(x_46re, x_46im, y_46re, y_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8), intent (in) :: y_46re
    real(8), intent (in) :: y_46im
    code = x_46im / y_46re
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return x_46_im / y_46_re;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return x_46_im / y_46_re

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(x_46_im / y_46_re)
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = x_46_im / y_46_re;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(x$46$im / y$46$re), $MachinePrecision]

Derivation

1. Initial program 58.2%

   \[\frac{x.im \cdot y.re - x.re \cdot y.im}{y.re \cdot y.re + y.im \cdot y.im} \]
2. Add Preprocessing

3. Taylor expanded in y.re around inf 45.8%

   \[\leadsto \color{blue}{\frac{x.im}{y.re}} \]

4. Final simplification 45.8%

   \[\leadsto \frac{x.im}{y.re} \]
5. Add Preprocessing

Reproduce

herbie shell --seed 2024033 
(FPCore (x.re x.im y.re y.im)
  :name "_divideComplex, imaginary part"
  :precision binary64
  (/ (- (* x.im y.re) (* x.re y.im)) (+ (* y.re y.re) (* y.im y.im))))