powComplex, imaginary part

Percentage Accurate: 40.6% → 79.4%

Time: 27.0s

Alternatives: 18

Speedup: 2.0×

• 35.1% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right)\\ e^{t_0 \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(t_0 \cdot y.im + \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right) \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (log (sqrt (+ (* x.re x.re) (* x.im x.im))))))
   (*
    (exp (- (* t_0 y.re) (* (atan2 x.im x.re) y.im)))
    (sin (+ (* t_0 y.im) (* (atan2 x.im x.re) y.re))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	return exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * 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
    real(8) :: t_0
    t_0 = log(sqrt(((x_46re * x_46re) + (x_46im * x_46im))))
    code = exp(((t_0 * y_46re) - (atan2(x_46im, x_46re) * y_46im))) * sin(((t_0 * y_46im) + (atan2(x_46im, x_46re) * 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) {
	double t_0 = Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	return Math.exp(((t_0 * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(((t_0 * y_46_im) + (Math.atan2(x_46_im, x_46_re) * y_46_re)));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))
	return math.exp(((t_0 * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(((t_0 * y_46_im) + (math.atan2(x_46_im, x_46_re) * y_46_re)))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))
	return Float64(exp(Float64(Float64(t_0 * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(Float64(t_0 * y_46_im) + Float64(atan(x_46_im, x_46_re) * y_46_re))))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re)));
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]}, N[(N[Exp[N[(N[(t$95$0 * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$0 * y$46$im), $MachinePrecision] + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Initial Program: 40.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right)\\ e^{t_0 \cdot y.re - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin \left(t_0 \cdot y.im + \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right) \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (log (sqrt (+ (* x.re x.re) (* x.im x.im))))))
   (*
    (exp (- (* t_0 y.re) (* (atan2 x.im x.re) y.im)))
    (sin (+ (* t_0 y.im) (* (atan2 x.im x.re) y.re))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	return exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * 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
    real(8) :: t_0
    t_0 = log(sqrt(((x_46re * x_46re) + (x_46im * x_46im))))
    code = exp(((t_0 * y_46re) - (atan2(x_46im, x_46re) * y_46im))) * sin(((t_0 * y_46im) + (atan2(x_46im, x_46re) * 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) {
	double t_0 = Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	return Math.exp(((t_0 * y_46_re) - (Math.atan2(x_46_im, x_46_re) * y_46_im))) * Math.sin(((t_0 * y_46_im) + (Math.atan2(x_46_im, x_46_re) * y_46_re)));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))
	return math.exp(((t_0 * y_46_re) - (math.atan2(x_46_im, x_46_re) * y_46_im))) * math.sin(((t_0 * y_46_im) + (math.atan2(x_46_im, x_46_re) * y_46_re)))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))
	return Float64(exp(Float64(Float64(t_0 * y_46_re) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(Float64(Float64(t_0 * y_46_im) + Float64(atan(x_46_im, x_46_re) * y_46_re))))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))));
	tmp = exp(((t_0 * y_46_re) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(((t_0 * y_46_im) + (atan2(x_46_im, x_46_re) * y_46_re)));
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]}, N[(N[Exp[N[(N[(t$95$0 * y$46$re), $MachinePrecision] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(N[(t$95$0 * y$46$im), $MachinePrecision] + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Alternative 1: 79.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_1 := \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\\ t_2 := \tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)\\ \mathbf{if}\;y.im \leq -6.8 \cdot 10^{+209}:\\ \;\;\;\;e^{t_2} \cdot \sin \left(\left|\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)\right|\right)\\ \mathbf{else}:\\ \;\;\;\;e^{\mathsf{fma}\left(t_1, y.re, t_2\right)} \cdot \sin \left(\mathsf{fma}\left(t_1, y.im, t_0\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* (atan2 x.im x.re) y.re))
        (t_1 (log (hypot x.re x.im)))
        (t_2 (* (atan2 x.im x.re) (- y.im))))
   (if (<= y.im -6.8e+209)
     (* (exp t_2) (sin (fabs (fma y.im (log (hypot x.im x.re)) t_0))))
     (* (exp (fma t_1 y.re t_2)) (sin (fma t_1 y.im t_0))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_1 = log(hypot(x_46_re, x_46_im));
	double t_2 = atan2(x_46_im, x_46_re) * -y_46_im;
	double tmp;
	if (y_46_im <= -6.8e+209) {
		tmp = exp(t_2) * sin(fabs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)));
	} else {
		tmp = exp(fma(t_1, y_46_re, t_2)) * sin(fma(t_1, y_46_im, t_0));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_1 = log(hypot(x_46_re, x_46_im))
	t_2 = Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))
	tmp = 0.0
	if (y_46_im <= -6.8e+209)
		tmp = Float64(exp(t_2) * sin(abs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0))));
	else
		tmp = Float64(exp(fma(t_1, y_46_re, t_2)) * sin(fma(t_1, y_46_im, t_0)));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$1 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]}, If[LessEqual[y$46$im, -6.8e+209], N[(N[Exp[t$95$2], $MachinePrecision] * N[Sin[N[Abs[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Exp[N[(t$95$1 * y$46$re + t$95$2), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 73.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_1 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{if}\;y.im \leq -2.5 \cdot 10^{+25}:\\ \;\;\;\;t_1 \cdot \sin \left(\left|\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)\right|\right)\\ \mathbf{elif}\;y.im \leq 4.9 \cdot 10^{+14}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right) \cdot \left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_1 \cdot \sin \left(\left|t_0\right|\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* (atan2 x.im x.re) y.re))
        (t_1 (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.im -2.5e+25)
     (* t_1 (sin (fabs (fma y.im (log (hypot x.im x.re)) t_0))))
     (if (<= y.im 4.9e+14)
       (*
        (sin (fma (log (hypot x.re x.im)) y.im t_0))
        (* (pow (hypot x.im x.re) y.re) (- 1.0 (* y.im (atan2 x.im x.re)))))
       (* t_1 (sin (fabs t_0)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_1 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_im <= -2.5e+25) {
		tmp = t_1 * sin(fabs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)));
	} else if (y_46_im <= 4.9e+14) {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - (y_46_im * atan2(x_46_im, x_46_re))));
	} else {
		tmp = t_1 * sin(fabs(t_0));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_1 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	tmp = 0.0
	if (y_46_im <= -2.5e+25)
		tmp = Float64(t_1 * sin(abs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0))));
	elseif (y_46_im <= 4.9e+14)
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - Float64(y_46_im * atan(x_46_im, x_46_re)))));
	else
		tmp = Float64(t_1 * sin(abs(t_0)));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$1 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$im, -2.5e+25], N[(t$95$1 * N[Sin[N[Abs[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 4.9e+14], N[(N[Sin[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[Sin[N[Abs[t$95$0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 73.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_1 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{if}\;y.im \leq -2.7 \cdot 10^{+27}:\\ \;\;\;\;t_1 \cdot \sin \left(\left|\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)\right|\right)\\ \mathbf{elif}\;y.im \leq 1.15 \cdot 10^{+23}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right) \cdot {\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re}\\ \mathbf{else}:\\ \;\;\;\;t_1 \cdot \sin \left(\left|t_0\right|\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* (atan2 x.im x.re) y.re))
        (t_1 (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.im -2.7e+27)
     (* t_1 (sin (fabs (fma y.im (log (hypot x.im x.re)) t_0))))
     (if (<= y.im 1.15e+23)
       (*
        (sin (fma (log (hypot x.re x.im)) y.im t_0))
        (pow (hypot x.im x.re) y.re))
       (* t_1 (sin (fabs t_0)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_1 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_im <= -2.7e+27) {
		tmp = t_1 * sin(fabs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)));
	} else if (y_46_im <= 1.15e+23) {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * pow(hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = t_1 * sin(fabs(t_0));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_1 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	tmp = 0.0
	if (y_46_im <= -2.7e+27)
		tmp = Float64(t_1 * sin(abs(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0))));
	elseif (y_46_im <= 1.15e+23)
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * (hypot(x_46_im, x_46_re) ^ y_46_re));
	else
		tmp = Float64(t_1 * sin(abs(t_0)));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$1 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$im, -2.7e+27], N[(t$95$1 * N[Sin[N[Abs[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.15e+23], N[(N[Sin[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision] * N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[Sin[N[Abs[t$95$0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 72.9% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ \mathbf{if}\;y.im \leq -7 \cdot 10^{+109} \lor \neg \left(y.im \leq 3.3 \cdot 10^{+22}\right):\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)} \cdot \sin \left(\left|t_0\right|\right)\\ \mathbf{else}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right) \cdot {\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re}\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* (atan2 x.im x.re) y.re)))
   (if (or (<= y.im -7e+109) (not (<= y.im 3.3e+22)))
     (* (exp (* (atan2 x.im x.re) (- y.im))) (sin (fabs t_0)))
     (*
      (sin (fma (log (hypot x.re x.im)) y.im t_0))
      (pow (hypot x.im x.re) y.re)))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	double tmp;
	if ((y_46_im <= -7e+109) || !(y_46_im <= 3.3e+22)) {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin(fabs(t_0));
	} else {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * pow(hypot(x_46_im, x_46_re), y_46_re);
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	tmp = 0.0
	if ((y_46_im <= -7e+109) || !(y_46_im <= 3.3e+22))
		tmp = Float64(exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))) * sin(abs(t_0)));
	else
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * (hypot(x_46_im, x_46_re) ^ y_46_re));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, If[Or[LessEqual[y$46$im, -7e+109], N[Not[LessEqual[y$46$im, 3.3e+22]], $MachinePrecision]], N[(N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision] * N[Sin[N[Abs[t$95$0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision] * N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 77.2% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_2 := e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - t_0} \cdot \sin t_1\\ \mathbf{if}\;y.re \leq -0.012:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y.re \leq 1.45:\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)} \cdot \sin \left(t_1 + y.im \cdot \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\right)\\ \mathbf{elif}\;y.re \leq 3.5 \cdot 10^{+53} \lor \neg \left(y.re \leq 2.1 \cdot 10^{+178}\right):\\ \;\;\;\;\frac{{\left(\mathsf{hypot}\left(x.re, x.im\right)\right)}^{y.re}}{1 + t_0} \cdot \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.im (atan2 x.im x.re)))
        (t_1 (* (atan2 x.im x.re) y.re))
        (t_2
         (*
          (exp (- (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im))))) t_0))
          (sin t_1))))
   (if (<= y.re -0.012)
     t_2
     (if (<= y.re 1.45)
       (*
        (exp (* (atan2 x.im x.re) (- y.im)))
        (sin (+ t_1 (* y.im (log (hypot x.re x.im))))))
       (if (or (<= y.re 3.5e+53) (not (<= y.re 2.1e+178)))
         (*
          (/ (pow (hypot x.re x.im) y.re) (+ 1.0 t_0))
          (sin (* y.im (log (hypot x.im x.re)))))
         t_2)))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * atan2(x_46_im, x_46_re);
	double t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - t_0)) * sin(t_1);
	double tmp;
	if (y_46_re <= -0.012) {
		tmp = t_2;
	} else if (y_46_re <= 1.45) {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	} else if ((y_46_re <= 3.5e+53) || !(y_46_re <= 2.1e+178)) {
		tmp = (pow(hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = Math.exp(((y_46_re * Math.log(Math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - t_0)) * Math.sin(t_1);
	double tmp;
	if (y_46_re <= -0.012) {
		tmp = t_2;
	} else if (y_46_re <= 1.45) {
		tmp = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)) * Math.sin((t_1 + (y_46_im * Math.log(Math.hypot(x_46_re, x_46_im)))));
	} else if ((y_46_re <= 3.5e+53) || !(y_46_re <= 2.1e+178)) {
		tmp = (Math.pow(Math.hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_1 = math.atan2(x_46_im, x_46_re) * y_46_re
	t_2 = math.exp(((y_46_re * math.log(math.sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - t_0)) * math.sin(t_1)
	tmp = 0
	if y_46_re <= -0.012:
		tmp = t_2
	elif y_46_re <= 1.45:
		tmp = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)) * math.sin((t_1 + (y_46_im * math.log(math.hypot(x_46_re, x_46_im)))))
	elif (y_46_re <= 3.5e+53) or not (y_46_re <= 2.1e+178):
		tmp = (math.pow(math.hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	else:
		tmp = t_2
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_1 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_2 = Float64(exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - t_0)) * sin(t_1))
	tmp = 0.0
	if (y_46_re <= -0.012)
		tmp = t_2;
	elseif (y_46_re <= 1.45)
		tmp = Float64(exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))) * sin(Float64(t_1 + Float64(y_46_im * log(hypot(x_46_re, x_46_im))))));
	elseif ((y_46_re <= 3.5e+53) || !(y_46_re <= 2.1e+178))
		tmp = Float64(Float64((hypot(x_46_re, x_46_im) ^ y_46_re) / Float64(1.0 + t_0)) * sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = y_46_im * atan2(x_46_im, x_46_re);
	t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	t_2 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - t_0)) * sin(t_1);
	tmp = 0.0;
	if (y_46_re <= -0.012)
		tmp = t_2;
	elseif (y_46_re <= 1.45)
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	elseif ((y_46_re <= 3.5e+53) || ~((y_46_re <= 2.1e+178)))
		tmp = ((hypot(x_46_re, x_46_im) ^ y_46_re) / (1.0 + t_0)) * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$2 = N[(N[Exp[N[(N[(y$46$re * N[Log[N[Sqrt[N[(N[(x$46$re * x$46$re), $MachinePrecision] + N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -0.012], t$95$2, If[LessEqual[y$46$re, 1.45], N[(N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y$46$re, 3.5e+53], N[Not[LessEqual[y$46$re, 2.1e+178]], $MachinePrecision]], N[(N[(N[Power[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 74.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_2 := \left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - t_0\right)\right) \cdot \sin t_1\\ \mathbf{if}\;y.re \leq -0.07:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y.re \leq 66000000000:\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)} \cdot \sin \left(t_1 + y.im \cdot \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\right)\\ \mathbf{elif}\;y.re \leq 2.9 \cdot 10^{+53}:\\ \;\;\;\;\sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right) \cdot \frac{{x.re}^{y.re}}{1 + t_0}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.im (atan2 x.im x.re)))
        (t_1 (* (atan2 x.im x.re) y.re))
        (t_2 (* (* (pow (hypot x.im x.re) y.re) (- 1.0 t_0)) (sin t_1))))
   (if (<= y.re -0.07)
     t_2
     (if (<= y.re 66000000000.0)
       (*
        (exp (* (atan2 x.im x.re) (- y.im)))
        (sin (+ t_1 (* y.im (log (hypot x.re x.im))))))
       (if (<= y.re 2.9e+53)
         (*
          (sin (* y.im (log (hypot x.im x.re))))
          (/ (pow x.re y.re) (+ 1.0 t_0)))
         t_2)))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * atan2(x_46_im, x_46_re);
	double t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * sin(t_1);
	double tmp;
	if (y_46_re <= -0.07) {
		tmp = t_2;
	} else if (y_46_re <= 66000000000.0) {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	} else if (y_46_re <= 2.9e+53) {
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * (pow(x_46_re, y_46_re) / (1.0 + t_0));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = (Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * Math.sin(t_1);
	double tmp;
	if (y_46_re <= -0.07) {
		tmp = t_2;
	} else if (y_46_re <= 66000000000.0) {
		tmp = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)) * Math.sin((t_1 + (y_46_im * Math.log(Math.hypot(x_46_re, x_46_im)))));
	} else if (y_46_re <= 2.9e+53) {
		tmp = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re)))) * (Math.pow(x_46_re, y_46_re) / (1.0 + t_0));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_1 = math.atan2(x_46_im, x_46_re) * y_46_re
	t_2 = (math.pow(math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * math.sin(t_1)
	tmp = 0
	if y_46_re <= -0.07:
		tmp = t_2
	elif y_46_re <= 66000000000.0:
		tmp = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)) * math.sin((t_1 + (y_46_im * math.log(math.hypot(x_46_re, x_46_im)))))
	elif y_46_re <= 2.9e+53:
		tmp = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re)))) * (math.pow(x_46_re, y_46_re) / (1.0 + t_0))
	else:
		tmp = t_2
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_1 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_2 = Float64(Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - t_0)) * sin(t_1))
	tmp = 0.0
	if (y_46_re <= -0.07)
		tmp = t_2;
	elseif (y_46_re <= 66000000000.0)
		tmp = Float64(exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))) * sin(Float64(t_1 + Float64(y_46_im * log(hypot(x_46_re, x_46_im))))));
	elseif (y_46_re <= 2.9e+53)
		tmp = Float64(sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))) * Float64((x_46_re ^ y_46_re) / Float64(1.0 + t_0)));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = y_46_im * atan2(x_46_im, x_46_re);
	t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	t_2 = ((hypot(x_46_im, x_46_re) ^ y_46_re) * (1.0 - t_0)) * sin(t_1);
	tmp = 0.0;
	if (y_46_re <= -0.07)
		tmp = t_2;
	elseif (y_46_re <= 66000000000.0)
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	elseif (y_46_re <= 2.9e+53)
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * ((x_46_re ^ y_46_re) / (1.0 + t_0));
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -0.07], t$95$2, If[LessEqual[y$46$re, 66000000000.0], N[(N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 2.9e+53], N[(N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 76.6% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ \mathbf{if}\;y.re \leq -0.00065:\\ \;\;\;\;\left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - t_0\right)\right) \cdot \sin t_1\\ \mathbf{elif}\;y.re \leq 1.45:\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)} \cdot \sin \left(t_1 + y.im \cdot \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{{\left(\mathsf{hypot}\left(x.re, x.im\right)\right)}^{y.re}}{1 + t_0} \cdot \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.im (atan2 x.im x.re))) (t_1 (* (atan2 x.im x.re) y.re)))
   (if (<= y.re -0.00065)
     (* (* (pow (hypot x.im x.re) y.re) (- 1.0 t_0)) (sin t_1))
     (if (<= y.re 1.45)
       (*
        (exp (* (atan2 x.im x.re) (- y.im)))
        (sin (+ t_1 (* y.im (log (hypot x.re x.im))))))
       (*
        (/ (pow (hypot x.re x.im) y.re) (+ 1.0 t_0))
        (sin (* y.im (log (hypot x.im x.re)))))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * atan2(x_46_im, x_46_re);
	double t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	double tmp;
	if (y_46_re <= -0.00065) {
		tmp = (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * sin(t_1);
	} else if (y_46_re <= 1.45) {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	} else {
		tmp = (pow(hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.atan2(x_46_im, x_46_re) * y_46_re;
	double tmp;
	if (y_46_re <= -0.00065) {
		tmp = (Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * Math.sin(t_1);
	} else if (y_46_re <= 1.45) {
		tmp = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)) * Math.sin((t_1 + (y_46_im * Math.log(Math.hypot(x_46_re, x_46_im)))));
	} else {
		tmp = (Math.pow(Math.hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_1 = math.atan2(x_46_im, x_46_re) * y_46_re
	tmp = 0
	if y_46_re <= -0.00065:
		tmp = (math.pow(math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * math.sin(t_1)
	elif y_46_re <= 1.45:
		tmp = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)) * math.sin((t_1 + (y_46_im * math.log(math.hypot(x_46_re, x_46_im)))))
	else:
		tmp = (math.pow(math.hypot(x_46_re, x_46_im), y_46_re) / (1.0 + t_0)) * math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_1 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	tmp = 0.0
	if (y_46_re <= -0.00065)
		tmp = Float64(Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - t_0)) * sin(t_1));
	elseif (y_46_re <= 1.45)
		tmp = Float64(exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))) * sin(Float64(t_1 + Float64(y_46_im * log(hypot(x_46_re, x_46_im))))));
	else
		tmp = Float64(Float64((hypot(x_46_re, x_46_im) ^ y_46_re) / Float64(1.0 + t_0)) * sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = y_46_im * atan2(x_46_im, x_46_re);
	t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	tmp = 0.0;
	if (y_46_re <= -0.00065)
		tmp = ((hypot(x_46_im, x_46_re) ^ y_46_re) * (1.0 - t_0)) * sin(t_1);
	elseif (y_46_re <= 1.45)
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im)))));
	else
		tmp = ((hypot(x_46_re, x_46_im) ^ y_46_re) / (1.0 + t_0)) * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, If[LessEqual[y$46$re, -0.00065], N[(N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.45], N[(N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 65.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ t_1 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ t_2 := \sin t_1\\ t_3 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ t_4 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_5 := \left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - t_4\right)\right) \cdot t_2\\ t_6 := 1 + t_4\\ t_7 := t_3 \cdot t_0\\ \mathbf{if}\;y.re \leq -0.0037:\\ \;\;\;\;t_5\\ \mathbf{elif}\;y.re \leq -8.2 \cdot 10^{-177}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_3\right)\\ \mathbf{elif}\;y.re \leq 3 \cdot 10^{-179}:\\ \;\;\;\;t_7\\ \mathbf{elif}\;y.re \leq 2.5 \cdot 10^{-67}:\\ \;\;\;\;\sin \left(t_1 + y.im \cdot \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\right) \cdot \frac{1}{t_6}\\ \mathbf{elif}\;y.re \leq 4 \cdot 10^{-54}:\\ \;\;\;\;t_7\\ \mathbf{elif}\;y.re \leq 165000000000:\\ \;\;\;\;t_2 \cdot \frac{{\left(\mathsf{hypot}\left(x.re, x.im\right)\right)}^{y.re}}{t_6}\\ \mathbf{elif}\;y.re \leq 1.15 \cdot 10^{+53}:\\ \;\;\;\;t_0 \cdot \frac{{x.re}^{y.re}}{t_6}\\ \mathbf{else}:\\ \;\;\;\;t_5\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (sin (* y.im (log (hypot x.im x.re)))))
        (t_1 (* (atan2 x.im x.re) y.re))
        (t_2 (sin t_1))
        (t_3 (exp (* (atan2 x.im x.re) (- y.im))))
        (t_4 (* y.im (atan2 x.im x.re)))
        (t_5 (* (* (pow (hypot x.im x.re) y.re) (- 1.0 t_4)) t_2))
        (t_6 (+ 1.0 t_4))
        (t_7 (* t_3 t_0)))
   (if (<= y.re -0.0037)
     t_5
     (if (<= y.re -8.2e-177)
       (* y.re (* (atan2 x.im x.re) t_3))
       (if (<= y.re 3e-179)
         t_7
         (if (<= y.re 2.5e-67)
           (* (sin (+ t_1 (* y.im (log (hypot x.re x.im))))) (/ 1.0 t_6))
           (if (<= y.re 4e-54)
             t_7
             (if (<= y.re 165000000000.0)
               (* t_2 (/ (pow (hypot x.re x.im) y.re) t_6))
               (if (<= y.re 1.15e+53)
                 (* t_0 (/ (pow x.re y.re) t_6))
                 t_5)))))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	double t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = sin(t_1);
	double t_3 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double t_4 = y_46_im * atan2(x_46_im, x_46_re);
	double t_5 = (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_4)) * t_2;
	double t_6 = 1.0 + t_4;
	double t_7 = t_3 * t_0;
	double tmp;
	if (y_46_re <= -0.0037) {
		tmp = t_5;
	} else if (y_46_re <= -8.2e-177) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_3);
	} else if (y_46_re <= 3e-179) {
		tmp = t_7;
	} else if (y_46_re <= 2.5e-67) {
		tmp = sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im))))) * (1.0 / t_6);
	} else if (y_46_re <= 4e-54) {
		tmp = t_7;
	} else if (y_46_re <= 165000000000.0) {
		tmp = t_2 * (pow(hypot(x_46_re, x_46_im), y_46_re) / t_6);
	} else if (y_46_re <= 1.15e+53) {
		tmp = t_0 * (pow(x_46_re, y_46_re) / t_6);
	} else {
		tmp = t_5;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	double t_1 = Math.atan2(x_46_im, x_46_re) * y_46_re;
	double t_2 = Math.sin(t_1);
	double t_3 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double t_4 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_5 = (Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_4)) * t_2;
	double t_6 = 1.0 + t_4;
	double t_7 = t_3 * t_0;
	double tmp;
	if (y_46_re <= -0.0037) {
		tmp = t_5;
	} else if (y_46_re <= -8.2e-177) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_3);
	} else if (y_46_re <= 3e-179) {
		tmp = t_7;
	} else if (y_46_re <= 2.5e-67) {
		tmp = Math.sin((t_1 + (y_46_im * Math.log(Math.hypot(x_46_re, x_46_im))))) * (1.0 / t_6);
	} else if (y_46_re <= 4e-54) {
		tmp = t_7;
	} else if (y_46_re <= 165000000000.0) {
		tmp = t_2 * (Math.pow(Math.hypot(x_46_re, x_46_im), y_46_re) / t_6);
	} else if (y_46_re <= 1.15e+53) {
		tmp = t_0 * (Math.pow(x_46_re, y_46_re) / t_6);
	} else {
		tmp = t_5;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	t_1 = math.atan2(x_46_im, x_46_re) * y_46_re
	t_2 = math.sin(t_1)
	t_3 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	t_4 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_5 = (math.pow(math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_4)) * t_2
	t_6 = 1.0 + t_4
	t_7 = t_3 * t_0
	tmp = 0
	if y_46_re <= -0.0037:
		tmp = t_5
	elif y_46_re <= -8.2e-177:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_3)
	elif y_46_re <= 3e-179:
		tmp = t_7
	elif y_46_re <= 2.5e-67:
		tmp = math.sin((t_1 + (y_46_im * math.log(math.hypot(x_46_re, x_46_im))))) * (1.0 / t_6)
	elif y_46_re <= 4e-54:
		tmp = t_7
	elif y_46_re <= 165000000000.0:
		tmp = t_2 * (math.pow(math.hypot(x_46_re, x_46_im), y_46_re) / t_6)
	elif y_46_re <= 1.15e+53:
		tmp = t_0 * (math.pow(x_46_re, y_46_re) / t_6)
	else:
		tmp = t_5
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re))))
	t_1 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	t_2 = sin(t_1)
	t_3 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	t_4 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_5 = Float64(Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - t_4)) * t_2)
	t_6 = Float64(1.0 + t_4)
	t_7 = Float64(t_3 * t_0)
	tmp = 0.0
	if (y_46_re <= -0.0037)
		tmp = t_5;
	elseif (y_46_re <= -8.2e-177)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_3));
	elseif (y_46_re <= 3e-179)
		tmp = t_7;
	elseif (y_46_re <= 2.5e-67)
		tmp = Float64(sin(Float64(t_1 + Float64(y_46_im * log(hypot(x_46_re, x_46_im))))) * Float64(1.0 / t_6));
	elseif (y_46_re <= 4e-54)
		tmp = t_7;
	elseif (y_46_re <= 165000000000.0)
		tmp = Float64(t_2 * Float64((hypot(x_46_re, x_46_im) ^ y_46_re) / t_6));
	elseif (y_46_re <= 1.15e+53)
		tmp = Float64(t_0 * Float64((x_46_re ^ y_46_re) / t_6));
	else
		tmp = t_5;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	t_1 = atan2(x_46_im, x_46_re) * y_46_re;
	t_2 = sin(t_1);
	t_3 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	t_4 = y_46_im * atan2(x_46_im, x_46_re);
	t_5 = ((hypot(x_46_im, x_46_re) ^ y_46_re) * (1.0 - t_4)) * t_2;
	t_6 = 1.0 + t_4;
	t_7 = t_3 * t_0;
	tmp = 0.0;
	if (y_46_re <= -0.0037)
		tmp = t_5;
	elseif (y_46_re <= -8.2e-177)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_3);
	elseif (y_46_re <= 3e-179)
		tmp = t_7;
	elseif (y_46_re <= 2.5e-67)
		tmp = sin((t_1 + (y_46_im * log(hypot(x_46_re, x_46_im))))) * (1.0 / t_6);
	elseif (y_46_re <= 4e-54)
		tmp = t_7;
	elseif (y_46_re <= 165000000000.0)
		tmp = t_2 * ((hypot(x_46_re, x_46_im) ^ y_46_re) / t_6);
	elseif (y_46_re <= 1.15e+53)
		tmp = t_0 * ((x_46_re ^ y_46_re) / t_6);
	else
		tmp = t_5;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, Block[{t$95$2 = N[Sin[t$95$1], $MachinePrecision]}, Block[{t$95$3 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - t$95$4), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]}, Block[{t$95$6 = N[(1.0 + t$95$4), $MachinePrecision]}, Block[{t$95$7 = N[(t$95$3 * t$95$0), $MachinePrecision]}, If[LessEqual[y$46$re, -0.0037], t$95$5, If[LessEqual[y$46$re, -8.2e-177], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 3e-179], t$95$7, If[LessEqual[y$46$re, 2.5e-67], N[(N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(1.0 / t$95$6), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 4e-54], t$95$7, If[LessEqual[y$46$re, 165000000000.0], N[(t$95$2 * N[(N[Power[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.15e+53], N[(t$95$0 * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], t$95$5]]]]]]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 66.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ t_2 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ t_3 := \left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - t_0\right)\right) \cdot \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ t_4 := y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_2\right)\\ \mathbf{if}\;y.re \leq -0.11:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y.re \leq -4.8 \cdot 10^{-179}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;y.re \leq 2.6 \cdot 10^{-56}:\\ \;\;\;\;t_2 \cdot t_1\\ \mathbf{elif}\;y.re \leq 2.8 \cdot 10^{-11}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;y.re \leq 1.7 \cdot 10^{+53}:\\ \;\;\;\;t_1 \cdot \frac{{x.re}^{y.re}}{1 + t_0}\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.im (atan2 x.im x.re)))
        (t_1 (sin (* y.im (log (hypot x.im x.re)))))
        (t_2 (exp (* (atan2 x.im x.re) (- y.im))))
        (t_3
         (*
          (* (pow (hypot x.im x.re) y.re) (- 1.0 t_0))
          (sin (* (atan2 x.im x.re) y.re))))
        (t_4 (* y.re (* (atan2 x.im x.re) t_2))))
   (if (<= y.re -0.11)
     t_3
     (if (<= y.re -4.8e-179)
       t_4
       (if (<= y.re 2.6e-56)
         (* t_2 t_1)
         (if (<= y.re 2.8e-11)
           t_4
           (if (<= y.re 1.7e+53)
             (* t_1 (/ (pow x.re y.re) (+ 1.0 t_0)))
             t_3)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * atan2(x_46_im, x_46_re);
	double t_1 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	double t_2 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double t_3 = (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * sin((atan2(x_46_im, x_46_re) * y_46_re));
	double t_4 = y_46_re * (atan2(x_46_im, x_46_re) * t_2);
	double tmp;
	if (y_46_re <= -0.11) {
		tmp = t_3;
	} else if (y_46_re <= -4.8e-179) {
		tmp = t_4;
	} else if (y_46_re <= 2.6e-56) {
		tmp = t_2 * t_1;
	} else if (y_46_re <= 2.8e-11) {
		tmp = t_4;
	} else if (y_46_re <= 1.7e+53) {
		tmp = t_1 * (pow(x_46_re, y_46_re) / (1.0 + t_0));
	} else {
		tmp = t_3;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	double t_2 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double t_3 = (Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	double t_4 = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_2);
	double tmp;
	if (y_46_re <= -0.11) {
		tmp = t_3;
	} else if (y_46_re <= -4.8e-179) {
		tmp = t_4;
	} else if (y_46_re <= 2.6e-56) {
		tmp = t_2 * t_1;
	} else if (y_46_re <= 2.8e-11) {
		tmp = t_4;
	} else if (y_46_re <= 1.7e+53) {
		tmp = t_1 * (Math.pow(x_46_re, y_46_re) / (1.0 + t_0));
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_1 = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	t_2 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	t_3 = (math.pow(math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	t_4 = y_46_re * (math.atan2(x_46_im, x_46_re) * t_2)
	tmp = 0
	if y_46_re <= -0.11:
		tmp = t_3
	elif y_46_re <= -4.8e-179:
		tmp = t_4
	elif y_46_re <= 2.6e-56:
		tmp = t_2 * t_1
	elif y_46_re <= 2.8e-11:
		tmp = t_4
	elif y_46_re <= 1.7e+53:
		tmp = t_1 * (math.pow(x_46_re, y_46_re) / (1.0 + t_0))
	else:
		tmp = t_3
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_1 = sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re))))
	t_2 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	t_3 = Float64(Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - t_0)) * sin(Float64(atan(x_46_im, x_46_re) * y_46_re)))
	t_4 = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_2))
	tmp = 0.0
	if (y_46_re <= -0.11)
		tmp = t_3;
	elseif (y_46_re <= -4.8e-179)
		tmp = t_4;
	elseif (y_46_re <= 2.6e-56)
		tmp = Float64(t_2 * t_1);
	elseif (y_46_re <= 2.8e-11)
		tmp = t_4;
	elseif (y_46_re <= 1.7e+53)
		tmp = Float64(t_1 * Float64((x_46_re ^ y_46_re) / Float64(1.0 + t_0)));
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = y_46_im * atan2(x_46_im, x_46_re);
	t_1 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	t_2 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	t_3 = ((hypot(x_46_im, x_46_re) ^ y_46_re) * (1.0 - t_0)) * sin((atan2(x_46_im, x_46_re) * y_46_re));
	t_4 = y_46_re * (atan2(x_46_im, x_46_re) * t_2);
	tmp = 0.0;
	if (y_46_re <= -0.11)
		tmp = t_3;
	elseif (y_46_re <= -4.8e-179)
		tmp = t_4;
	elseif (y_46_re <= 2.6e-56)
		tmp = t_2 * t_1;
	elseif (y_46_re <= 2.8e-11)
		tmp = t_4;
	elseif (y_46_re <= 1.7e+53)
		tmp = t_1 * ((x_46_re ^ y_46_re) / (1.0 + t_0));
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$re, -0.11], t$95$3, If[LessEqual[y$46$re, -4.8e-179], t$95$4, If[LessEqual[y$46$re, 2.6e-56], N[(t$95$2 * t$95$1), $MachinePrecision], If[LessEqual[y$46$re, 2.8e-11], t$95$4, If[LessEqual[y$46$re, 1.7e+53], N[(t$95$1 * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 66.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ t_2 := \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ t_3 := \left({\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re} \cdot \left(1 - t_0\right)\right) \cdot t_2\\ t_4 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ t_5 := 1 + t_0\\ \mathbf{if}\;y.re \leq -0.13:\\ \;\;\;\;t_3\\ \mathbf{elif}\;y.re \leq -8 \cdot 10^{-178}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_4\right)\\ \mathbf{elif}\;y.re \leq 6.8 \cdot 10^{-55}:\\ \;\;\;\;t_4 \cdot t_1\\ \mathbf{elif}\;y.re \leq 165000000000:\\ \;\;\;\;t_2 \cdot \frac{{\left(\mathsf{hypot}\left(x.re, x.im\right)\right)}^{y.re}}{t_5}\\ \mathbf{elif}\;y.re \leq 6 \cdot 10^{+85}:\\ \;\;\;\;t_1 \cdot \frac{{x.re}^{y.re}}{t_5}\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.im (atan2 x.im x.re)))
        (t_1 (sin (* y.im (log (hypot x.im x.re)))))
        (t_2 (sin (* (atan2 x.im x.re) y.re)))
        (t_3 (* (* (pow (hypot x.im x.re) y.re) (- 1.0 t_0)) t_2))
        (t_4 (exp (* (atan2 x.im x.re) (- y.im))))
        (t_5 (+ 1.0 t_0)))
   (if (<= y.re -0.13)
     t_3
     (if (<= y.re -8e-178)
       (* y.re (* (atan2 x.im x.re) t_4))
       (if (<= y.re 6.8e-55)
         (* t_4 t_1)
         (if (<= y.re 165000000000.0)
           (* t_2 (/ (pow (hypot x.re x.im) y.re) t_5))
           (if (<= y.re 6e+85) (* t_1 (/ (pow x.re y.re) t_5)) t_3)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * atan2(x_46_im, x_46_re);
	double t_1 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	double t_2 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	double t_3 = (pow(hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * t_2;
	double t_4 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double t_5 = 1.0 + t_0;
	double tmp;
	if (y_46_re <= -0.13) {
		tmp = t_3;
	} else if (y_46_re <= -8e-178) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_4);
	} else if (y_46_re <= 6.8e-55) {
		tmp = t_4 * t_1;
	} else if (y_46_re <= 165000000000.0) {
		tmp = t_2 * (pow(hypot(x_46_re, x_46_im), y_46_re) / t_5);
	} else if (y_46_re <= 6e+85) {
		tmp = t_1 * (pow(x_46_re, y_46_re) / t_5);
	} else {
		tmp = t_3;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_im * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	double t_2 = Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	double t_3 = (Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * t_2;
	double t_4 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double t_5 = 1.0 + t_0;
	double tmp;
	if (y_46_re <= -0.13) {
		tmp = t_3;
	} else if (y_46_re <= -8e-178) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_4);
	} else if (y_46_re <= 6.8e-55) {
		tmp = t_4 * t_1;
	} else if (y_46_re <= 165000000000.0) {
		tmp = t_2 * (Math.pow(Math.hypot(x_46_re, x_46_im), y_46_re) / t_5);
	} else if (y_46_re <= 6e+85) {
		tmp = t_1 * (Math.pow(x_46_re, y_46_re) / t_5);
	} else {
		tmp = t_3;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_im * math.atan2(x_46_im, x_46_re)
	t_1 = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	t_2 = math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	t_3 = (math.pow(math.hypot(x_46_im, x_46_re), y_46_re) * (1.0 - t_0)) * t_2
	t_4 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	t_5 = 1.0 + t_0
	tmp = 0
	if y_46_re <= -0.13:
		tmp = t_3
	elif y_46_re <= -8e-178:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_4)
	elif y_46_re <= 6.8e-55:
		tmp = t_4 * t_1
	elif y_46_re <= 165000000000.0:
		tmp = t_2 * (math.pow(math.hypot(x_46_re, x_46_im), y_46_re) / t_5)
	elif y_46_re <= 6e+85:
		tmp = t_1 * (math.pow(x_46_re, y_46_re) / t_5)
	else:
		tmp = t_3
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_im * atan(x_46_im, x_46_re))
	t_1 = sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re))))
	t_2 = sin(Float64(atan(x_46_im, x_46_re) * y_46_re))
	t_3 = Float64(Float64((hypot(x_46_im, x_46_re) ^ y_46_re) * Float64(1.0 - t_0)) * t_2)
	t_4 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	t_5 = Float64(1.0 + t_0)
	tmp = 0.0
	if (y_46_re <= -0.13)
		tmp = t_3;
	elseif (y_46_re <= -8e-178)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_4));
	elseif (y_46_re <= 6.8e-55)
		tmp = Float64(t_4 * t_1);
	elseif (y_46_re <= 165000000000.0)
		tmp = Float64(t_2 * Float64((hypot(x_46_re, x_46_im) ^ y_46_re) / t_5));
	elseif (y_46_re <= 6e+85)
		tmp = Float64(t_1 * Float64((x_46_re ^ y_46_re) / t_5));
	else
		tmp = t_3;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = y_46_im * atan2(x_46_im, x_46_re);
	t_1 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	t_2 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	t_3 = ((hypot(x_46_im, x_46_re) ^ y_46_re) * (1.0 - t_0)) * t_2;
	t_4 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	t_5 = 1.0 + t_0;
	tmp = 0.0;
	if (y_46_re <= -0.13)
		tmp = t_3;
	elseif (y_46_re <= -8e-178)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_4);
	elseif (y_46_re <= 6.8e-55)
		tmp = t_4 * t_1;
	elseif (y_46_re <= 165000000000.0)
		tmp = t_2 * ((hypot(x_46_re, x_46_im) ^ y_46_re) / t_5);
	elseif (y_46_re <= 6e+85)
		tmp = t_1 * ((x_46_re ^ y_46_re) / t_5);
	else
		tmp = t_3;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] * N[(1.0 - t$95$0), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$5 = N[(1.0 + t$95$0), $MachinePrecision]}, If[LessEqual[y$46$re, -0.13], t$95$3, If[LessEqual[y$46$re, -8e-178], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$4), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 6.8e-55], N[(t$95$4 * t$95$1), $MachinePrecision], If[LessEqual[y$46$re, 165000000000.0], N[(t$95$2 * N[(N[Power[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 6e+85], N[(t$95$1 * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], t$95$3]]]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 60.5% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ t_1 := \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ t_2 := \frac{{x.re}^{y.re}}{1 + y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\ t_3 := \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ \mathbf{if}\;y.re \leq -215000000:\\ \;\;\;\;t_1 \cdot t_2\\ \mathbf{elif}\;y.re \leq -4.6 \cdot 10^{-176}:\\ \;\;\;\;t_0 \cdot t_1\\ \mathbf{elif}\;y.re \leq 1.7 \cdot 10^{-56}:\\ \;\;\;\;t_0 \cdot t_3\\ \mathbf{elif}\;y.re \leq 2.8 \cdot 10^{-11}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_0\right)\\ \mathbf{else}:\\ \;\;\;\;t_3 \cdot t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (exp (* (atan2 x.im x.re) (- y.im))))
        (t_1 (sin (* (atan2 x.im x.re) y.re)))
        (t_2 (/ (pow x.re y.re) (+ 1.0 (* y.im (atan2 x.im x.re)))))
        (t_3 (sin (* y.im (log (hypot x.im x.re))))))
   (if (<= y.re -215000000.0)
     (* t_1 t_2)
     (if (<= y.re -4.6e-176)
       (* t_0 t_1)
       (if (<= y.re 1.7e-56)
         (* t_0 t_3)
         (if (<= y.re 2.8e-11)
           (* y.re (* (atan2 x.im x.re) t_0))
           (* t_3 t_2)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double t_1 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	double t_2 = pow(x_46_re, y_46_re) / (1.0 + (y_46_im * atan2(x_46_im, x_46_re)));
	double t_3 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	double tmp;
	if (y_46_re <= -215000000.0) {
		tmp = t_1 * t_2;
	} else if (y_46_re <= -4.6e-176) {
		tmp = t_0 * t_1;
	} else if (y_46_re <= 1.7e-56) {
		tmp = t_0 * t_3;
	} else if (y_46_re <= 2.8e-11) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_0);
	} else {
		tmp = t_3 * t_2;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double t_1 = Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	double t_2 = Math.pow(x_46_re, y_46_re) / (1.0 + (y_46_im * Math.atan2(x_46_im, x_46_re)));
	double t_3 = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	double tmp;
	if (y_46_re <= -215000000.0) {
		tmp = t_1 * t_2;
	} else if (y_46_re <= -4.6e-176) {
		tmp = t_0 * t_1;
	} else if (y_46_re <= 1.7e-56) {
		tmp = t_0 * t_3;
	} else if (y_46_re <= 2.8e-11) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_0);
	} else {
		tmp = t_3 * t_2;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	t_1 = math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	t_2 = math.pow(x_46_re, y_46_re) / (1.0 + (y_46_im * math.atan2(x_46_im, x_46_re)))
	t_3 = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	tmp = 0
	if y_46_re <= -215000000.0:
		tmp = t_1 * t_2
	elif y_46_re <= -4.6e-176:
		tmp = t_0 * t_1
	elif y_46_re <= 1.7e-56:
		tmp = t_0 * t_3
	elif y_46_re <= 2.8e-11:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_0)
	else:
		tmp = t_3 * t_2
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	t_1 = sin(Float64(atan(x_46_im, x_46_re) * y_46_re))
	t_2 = Float64((x_46_re ^ y_46_re) / Float64(1.0 + Float64(y_46_im * atan(x_46_im, x_46_re))))
	t_3 = sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re))))
	tmp = 0.0
	if (y_46_re <= -215000000.0)
		tmp = Float64(t_1 * t_2);
	elseif (y_46_re <= -4.6e-176)
		tmp = Float64(t_0 * t_1);
	elseif (y_46_re <= 1.7e-56)
		tmp = Float64(t_0 * t_3);
	elseif (y_46_re <= 2.8e-11)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_0));
	else
		tmp = Float64(t_3 * t_2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	t_1 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	t_2 = (x_46_re ^ y_46_re) / (1.0 + (y_46_im * atan2(x_46_im, x_46_re)));
	t_3 = sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	tmp = 0.0;
	if (y_46_re <= -215000000.0)
		tmp = t_1 * t_2;
	elseif (y_46_re <= -4.6e-176)
		tmp = t_0 * t_1;
	elseif (y_46_re <= 1.7e-56)
		tmp = t_0 * t_3;
	elseif (y_46_re <= 2.8e-11)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_0);
	else
		tmp = t_3 * t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / N[(1.0 + N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -215000000.0], N[(t$95$1 * t$95$2), $MachinePrecision], If[LessEqual[y$46$re, -4.6e-176], N[(t$95$0 * t$95$1), $MachinePrecision], If[LessEqual[y$46$re, 1.7e-56], N[(t$95$0 * t$95$3), $MachinePrecision], If[LessEqual[y$46$re, 2.8e-11], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(t$95$3 * t$95$2), $MachinePrecision]]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 59.7% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ t_1 := t_0 \cdot \frac{{x.re}^{y.re}}{1 + y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\ t_2 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{if}\;y.re \leq -1300000000:\\ \;\;\;\;t_1\\ \mathbf{elif}\;y.re \leq -5.8 \cdot 10^{-179}:\\ \;\;\;\;t_2 \cdot t_0\\ \mathbf{elif}\;y.re \leq 1.72 \cdot 10^{-56}:\\ \;\;\;\;t_2 \cdot \sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right)\\ \mathbf{elif}\;y.re \leq 3 \cdot 10^{+15}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_2\right)\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (sin (* (atan2 x.im x.re) y.re)))
        (t_1 (* t_0 (/ (pow x.re y.re) (+ 1.0 (* y.im (atan2 x.im x.re))))))
        (t_2 (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.re -1300000000.0)
     t_1
     (if (<= y.re -5.8e-179)
       (* t_2 t_0)
       (if (<= y.re 1.72e-56)
         (* t_2 (sin (* y.im (log (hypot x.im x.re)))))
         (if (<= y.re 3e+15) (* y.re (* (atan2 x.im x.re) t_2)) t_1))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	double t_1 = t_0 * (pow(x_46_re, y_46_re) / (1.0 + (y_46_im * atan2(x_46_im, x_46_re))));
	double t_2 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_re <= -1300000000.0) {
		tmp = t_1;
	} else if (y_46_re <= -5.8e-179) {
		tmp = t_2 * t_0;
	} else if (y_46_re <= 1.72e-56) {
		tmp = t_2 * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	} else if (y_46_re <= 3e+15) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_2);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	double t_1 = t_0 * (Math.pow(x_46_re, y_46_re) / (1.0 + (y_46_im * Math.atan2(x_46_im, x_46_re))));
	double t_2 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_re <= -1300000000.0) {
		tmp = t_1;
	} else if (y_46_re <= -5.8e-179) {
		tmp = t_2 * t_0;
	} else if (y_46_re <= 1.72e-56) {
		tmp = t_2 * Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re))));
	} else if (y_46_re <= 3e+15) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_2);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	t_1 = t_0 * (math.pow(x_46_re, y_46_re) / (1.0 + (y_46_im * math.atan2(x_46_im, x_46_re))))
	t_2 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	tmp = 0
	if y_46_re <= -1300000000.0:
		tmp = t_1
	elif y_46_re <= -5.8e-179:
		tmp = t_2 * t_0
	elif y_46_re <= 1.72e-56:
		tmp = t_2 * math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re))))
	elif y_46_re <= 3e+15:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_2)
	else:
		tmp = t_1
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = sin(Float64(atan(x_46_im, x_46_re) * y_46_re))
	t_1 = Float64(t_0 * Float64((x_46_re ^ y_46_re) / Float64(1.0 + Float64(y_46_im * atan(x_46_im, x_46_re)))))
	t_2 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	tmp = 0.0
	if (y_46_re <= -1300000000.0)
		tmp = t_1;
	elseif (y_46_re <= -5.8e-179)
		tmp = Float64(t_2 * t_0);
	elseif (y_46_re <= 1.72e-56)
		tmp = Float64(t_2 * sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))));
	elseif (y_46_re <= 3e+15)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_2));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	t_1 = t_0 * ((x_46_re ^ y_46_re) / (1.0 + (y_46_im * atan2(x_46_im, x_46_re))));
	t_2 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	tmp = 0.0;
	if (y_46_re <= -1300000000.0)
		tmp = t_1;
	elseif (y_46_re <= -5.8e-179)
		tmp = t_2 * t_0;
	elseif (y_46_re <= 1.72e-56)
		tmp = t_2 * sin((y_46_im * log(hypot(x_46_im, x_46_re))));
	elseif (y_46_re <= 3e+15)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_2);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / N[(1.0 + N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -1300000000.0], t$95$1, If[LessEqual[y$46$re, -5.8e-179], N[(t$95$2 * t$95$0), $MachinePrecision], If[LessEqual[y$46$re, 1.72e-56], N[(t$95$2 * N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 3e+15], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 53.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ t_2 := t_1 \cdot \frac{{x.re}^{y.re}}{t_0}\\ t_3 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{if}\;y.re \leq -41000000:\\ \;\;\;\;t_2\\ \mathbf{elif}\;y.re \leq -8.5 \cdot 10^{-197}:\\ \;\;\;\;t_3 \cdot t_1\\ \mathbf{elif}\;y.re \leq 9.2 \cdot 10^{-237}:\\ \;\;\;\;\sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right) \cdot \frac{1}{t_0}\\ \mathbf{elif}\;y.re \leq 1.8 \cdot 10^{+15}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_3\right)\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (+ 1.0 (* y.im (atan2 x.im x.re))))
        (t_1 (sin (* (atan2 x.im x.re) y.re)))
        (t_2 (* t_1 (/ (pow x.re y.re) t_0)))
        (t_3 (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.re -41000000.0)
     t_2
     (if (<= y.re -8.5e-197)
       (* t_3 t_1)
       (if (<= y.re 9.2e-237)
         (* (sin (* y.im (log (hypot x.im x.re)))) (/ 1.0 t_0))
         (if (<= y.re 1.8e+15) (* y.re (* (atan2 x.im x.re) t_3)) t_2))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = 1.0 + (y_46_im * atan2(x_46_im, x_46_re));
	double t_1 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	double t_2 = t_1 * (pow(x_46_re, y_46_re) / t_0);
	double t_3 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_re <= -41000000.0) {
		tmp = t_2;
	} else if (y_46_re <= -8.5e-197) {
		tmp = t_3 * t_1;
	} else if (y_46_re <= 9.2e-237) {
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * (1.0 / t_0);
	} else if (y_46_re <= 1.8e+15) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_3);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = 1.0 + (y_46_im * Math.atan2(x_46_im, x_46_re));
	double t_1 = Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	double t_2 = t_1 * (Math.pow(x_46_re, y_46_re) / t_0);
	double t_3 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_re <= -41000000.0) {
		tmp = t_2;
	} else if (y_46_re <= -8.5e-197) {
		tmp = t_3 * t_1;
	} else if (y_46_re <= 9.2e-237) {
		tmp = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re)))) * (1.0 / t_0);
	} else if (y_46_re <= 1.8e+15) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_3);
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = 1.0 + (y_46_im * math.atan2(x_46_im, x_46_re))
	t_1 = math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	t_2 = t_1 * (math.pow(x_46_re, y_46_re) / t_0)
	t_3 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	tmp = 0
	if y_46_re <= -41000000.0:
		tmp = t_2
	elif y_46_re <= -8.5e-197:
		tmp = t_3 * t_1
	elif y_46_re <= 9.2e-237:
		tmp = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re)))) * (1.0 / t_0)
	elif y_46_re <= 1.8e+15:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_3)
	else:
		tmp = t_2
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(1.0 + Float64(y_46_im * atan(x_46_im, x_46_re)))
	t_1 = sin(Float64(atan(x_46_im, x_46_re) * y_46_re))
	t_2 = Float64(t_1 * Float64((x_46_re ^ y_46_re) / t_0))
	t_3 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	tmp = 0.0
	if (y_46_re <= -41000000.0)
		tmp = t_2;
	elseif (y_46_re <= -8.5e-197)
		tmp = Float64(t_3 * t_1);
	elseif (y_46_re <= 9.2e-237)
		tmp = Float64(sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))) * Float64(1.0 / t_0));
	elseif (y_46_re <= 1.8e+15)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_3));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = 1.0 + (y_46_im * atan2(x_46_im, x_46_re));
	t_1 = sin((atan2(x_46_im, x_46_re) * y_46_re));
	t_2 = t_1 * ((x_46_re ^ y_46_re) / t_0);
	t_3 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	tmp = 0.0;
	if (y_46_re <= -41000000.0)
		tmp = t_2;
	elseif (y_46_re <= -8.5e-197)
		tmp = t_3 * t_1;
	elseif (y_46_re <= 9.2e-237)
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * (1.0 / t_0);
	elseif (y_46_re <= 1.8e+15)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_3);
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(1.0 + N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 * N[(N[Power[x$46$re, y$46$re], $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -41000000.0], t$95$2, If[LessEqual[y$46$re, -8.5e-197], N[(t$95$3 * t$95$1), $MachinePrecision], If[LessEqual[y$46$re, 9.2e-237], N[(N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(1.0 / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.8e+15], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$3), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 14: 45.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{if}\;y.im \leq -1.05 \cdot 10^{+25}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot t_0\right)\\ \mathbf{elif}\;y.im \leq -6.2 \cdot 10^{-108} \lor \neg \left(y.im \leq 1.1 \cdot 10^{-174}\right) \land y.im \leq 130:\\ \;\;\;\;\sin \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right) \cdot \frac{1}{1 + y.im \cdot \tan^{-1}_* \frac{x.im}{x.re}}\\ \mathbf{else}:\\ \;\;\;\;t_0 \cdot \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.im -1.05e+25)
     (* y.re (* (atan2 x.im x.re) t_0))
     (if (or (<= y.im -6.2e-108)
             (and (not (<= y.im 1.1e-174)) (<= y.im 130.0)))
       (*
        (sin (* y.im (log (hypot x.im x.re))))
        (/ 1.0 (+ 1.0 (* y.im (atan2 x.im x.re)))))
       (* t_0 (sin (* (atan2 x.im x.re) y.re)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_im <= -1.05e+25) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_0);
	} else if ((y_46_im <= -6.2e-108) || (!(y_46_im <= 1.1e-174) && (y_46_im <= 130.0))) {
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * (1.0 / (1.0 + (y_46_im * atan2(x_46_im, x_46_re))));
	} else {
		tmp = t_0 * sin((atan2(x_46_im, x_46_re) * y_46_re));
	}
	return tmp;
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	double tmp;
	if (y_46_im <= -1.05e+25) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * t_0);
	} else if ((y_46_im <= -6.2e-108) || (!(y_46_im <= 1.1e-174) && (y_46_im <= 130.0))) {
		tmp = Math.sin((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re)))) * (1.0 / (1.0 + (y_46_im * Math.atan2(x_46_im, x_46_re))));
	} else {
		tmp = t_0 * Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	tmp = 0
	if y_46_im <= -1.05e+25:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * t_0)
	elif (y_46_im <= -6.2e-108) or (not (y_46_im <= 1.1e-174) and (y_46_im <= 130.0)):
		tmp = math.sin((y_46_im * math.log(math.hypot(x_46_im, x_46_re)))) * (1.0 / (1.0 + (y_46_im * math.atan2(x_46_im, x_46_re))))
	else:
		tmp = t_0 * math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))
	tmp = 0.0
	if (y_46_im <= -1.05e+25)
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * t_0));
	elseif ((y_46_im <= -6.2e-108) || (!(y_46_im <= 1.1e-174) && (y_46_im <= 130.0)))
		tmp = Float64(sin(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))) * Float64(1.0 / Float64(1.0 + Float64(y_46_im * atan(x_46_im, x_46_re)))));
	else
		tmp = Float64(t_0 * sin(Float64(atan(x_46_im, x_46_re) * y_46_re)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	tmp = 0.0;
	if (y_46_im <= -1.05e+25)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * t_0);
	elseif ((y_46_im <= -6.2e-108) || (~((y_46_im <= 1.1e-174)) && (y_46_im <= 130.0)))
		tmp = sin((y_46_im * log(hypot(x_46_im, x_46_re)))) * (1.0 / (1.0 + (y_46_im * atan2(x_46_im, x_46_re))));
	else
		tmp = t_0 * sin((atan2(x_46_im, x_46_re) * y_46_re));
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$im, -1.05e+25], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y$46$im, -6.2e-108], And[N[Not[LessEqual[y$46$im, 1.1e-174]], $MachinePrecision], LessEqual[y$46$im, 130.0]]], N[(N[Sin[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(1.0 / N[(1.0 + N[(y$46$im * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[Sin[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 15: 40.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\\ \mathbf{if}\;x.re \leq -3.5 \cdot 10^{-155}:\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)} \cdot \sin t_0\\ \mathbf{else}:\\ \;\;\;\;t_0 \cdot {\left(e^{y.im}\right)}^{\left(-\tan^{-1}_* \frac{x.im}{x.re}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* (atan2 x.im x.re) y.re)))
   (if (<= x.re -3.5e-155)
     (* (exp (* (atan2 x.im x.re) (- y.im))) (sin t_0))
     (* t_0 (pow (exp y.im) (- (atan2 x.im x.re)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	double tmp;
	if (x_46_re <= -3.5e-155) {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin(t_0);
	} else {
		tmp = t_0 * pow(exp(y_46_im), -atan2(x_46_im, x_46_re));
	}
	return tmp;
}

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
    real(8) :: t_0
    real(8) :: tmp
    t_0 = atan2(x_46im, x_46re) * y_46re
    if (x_46re <= (-3.5d-155)) then
        tmp = exp((atan2(x_46im, x_46re) * -y_46im)) * sin(t_0)
    else
        tmp = t_0 * (exp(y_46im) ** -atan2(x_46im, x_46re))
    end if
    code = tmp
end function

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = Math.atan2(x_46_im, x_46_re) * y_46_re;
	double tmp;
	if (x_46_re <= -3.5e-155) {
		tmp = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)) * Math.sin(t_0);
	} else {
		tmp = t_0 * Math.pow(Math.exp(y_46_im), -Math.atan2(x_46_im, x_46_re));
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.atan2(x_46_im, x_46_re) * y_46_re
	tmp = 0
	if x_46_re <= -3.5e-155:
		tmp = math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)) * math.sin(t_0)
	else:
		tmp = t_0 * math.pow(math.exp(y_46_im), -math.atan2(x_46_im, x_46_re))
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(atan(x_46_im, x_46_re) * y_46_re)
	tmp = 0.0
	if (x_46_re <= -3.5e-155)
		tmp = Float64(exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))) * sin(t_0));
	else
		tmp = Float64(t_0 * (exp(y_46_im) ^ Float64(-atan(x_46_im, x_46_re))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = atan2(x_46_im, x_46_re) * y_46_re;
	tmp = 0.0;
	if (x_46_re <= -3.5e-155)
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im)) * sin(t_0);
	else
		tmp = t_0 * (exp(y_46_im) ^ -atan2(x_46_im, x_46_re));
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$re), $MachinePrecision]}, If[LessEqual[x$46$re, -3.5e-155], N[(N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], N[(t$95$0 * N[Power[N[Exp[y$46$im], $MachinePrecision], (-N[ArcTan[x$46$im / x$46$re], $MachinePrecision])], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 16: 40.6% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right) \cdot {\left(e^{y.im}\right)}^{\left(-\tan^{-1}_* \frac{x.im}{x.re}\right)} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (* (* (atan2 x.im x.re) y.re) (pow (exp y.im) (- (atan2 x.im x.re)))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return (atan2(x_46_im, x_46_re) * y_46_re) * pow(exp(y_46_im), -atan2(x_46_im, x_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 = (atan2(x_46im, x_46re) * y_46re) * (exp(y_46im) ** -atan2(x_46im, x_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 (Math.atan2(x_46_im, x_46_re) * y_46_re) * Math.pow(Math.exp(y_46_im), -Math.atan2(x_46_im, x_46_re));
}

Python

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

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(Float64(atan(x_46_im, x_46_re) * y_46_re) * (exp(y_46_im) ^ Float64(-atan(x_46_im, x_46_re))))
end

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 17: 40.0% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\right) \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (* y.re (* (atan2 x.im x.re) (exp (* (atan2 x.im x.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 * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -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 = y_46re * (atan2(x_46im, x_46re) * exp((atan2(x_46im, x_46re) * -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 y_46_re * (Math.atan2(x_46_im, x_46_re) * Math.exp((Math.atan2(x_46_im, x_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.atan2(x_46_im, x_46_re) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 18: 14.0% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \sin \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot y.re\right) \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (sin (* (atan2 x.im x.re) y.re)))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return sin((atan2(x_46_im, x_46_re) * 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 = sin((atan2(x_46im, x_46re) * 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 Math.sin((Math.atan2(x_46_im, x_46_re) * y_46_re));
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	return math.sin((math.atan2(x_46_im, x_46_re) * y_46_re))

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return sin(Float64(atan(x_46_im, x_46_re) * y_46_re))
end

MATLAB

function tmp = code(x_46_re, x_46_im, y_46_re, y_46_im)
	tmp = sin((atan2(x_46_im, x_46_re) * y_46_re));
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2024003 
(FPCore (x.re x.im y.re y.im)
  :name "powComplex, imaginary part"
  :precision binary64
  (* (exp (- (* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.re) (* (atan2 x.im x.re) y.im))) (sin (+ (* (log (sqrt (+ (* x.re x.re) (* x.im x.im)))) y.im) (* (atan2 x.im x.re) y.re)))))