powComplex, imaginary part

Percentage Accurate: 41.0% → 79.8%

Time: 57.4s

Alternatives: 22

Speedup: 2.6×

• 35.7% 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: 41.0% 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.8% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sqrt[3]{\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)}\\ t_2 := \sqrt[3]{t_1}\\ t_3 := \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\\ t_4 := e^{\mathsf{fma}\left(t_3, y.re, \tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)\right)}\\ \mathbf{if}\;x.im \leq -2.6 \cdot 10^{-162}:\\ \;\;\;\;t_4 \cdot \sin \left(t_2 \cdot {\left(\sqrt[3]{{t_1}^{2}}\right)}^{4}\right)\\ \mathbf{elif}\;x.im \leq 1.65 \cdot 10^{+99}:\\ \;\;\;\;t_4 \cdot \sin \left(t_2 \cdot {\left({\left({\left(\sqrt[3]{t_2}\right)}^{2}\right)}^{3}\right)}^{4}\right)\\ \mathbf{else}:\\ \;\;\;\;t_4 \cdot \sin \left({\left(\sqrt[3]{\mathsf{fma}\left(y.im, t_3, t_0\right)}\right)}^{3}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.re (atan2 x.im x.re)))
        (t_1 (cbrt (fma y.im (log (hypot x.im x.re)) t_0)))
        (t_2 (cbrt t_1))
        (t_3 (log (hypot x.re x.im)))
        (t_4 (exp (fma t_3 y.re (* (atan2 x.im x.re) (- y.im))))))
   (if (<= x.im -2.6e-162)
     (* t_4 (sin (* t_2 (pow (cbrt (pow t_1 2.0)) 4.0))))
     (if (<= x.im 1.65e+99)
       (* t_4 (sin (* t_2 (pow (pow (pow (cbrt t_2) 2.0) 3.0) 4.0))))
       (* t_4 (sin (pow (cbrt (fma y.im t_3 t_0)) 3.0)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = cbrt(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0));
	double t_2 = cbrt(t_1);
	double t_3 = log(hypot(x_46_re, x_46_im));
	double t_4 = exp(fma(t_3, y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im)));
	double tmp;
	if (x_46_im <= -2.6e-162) {
		tmp = t_4 * sin((t_2 * pow(cbrt(pow(t_1, 2.0)), 4.0)));
	} else if (x_46_im <= 1.65e+99) {
		tmp = t_4 * sin((t_2 * pow(pow(pow(cbrt(t_2), 2.0), 3.0), 4.0)));
	} else {
		tmp = t_4 * sin(pow(cbrt(fma(y_46_im, t_3, t_0)), 3.0));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_1 = cbrt(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0))
	t_2 = cbrt(t_1)
	t_3 = log(hypot(x_46_re, x_46_im))
	t_4 = exp(fma(t_3, y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
	tmp = 0.0
	if (x_46_im <= -2.6e-162)
		tmp = Float64(t_4 * sin(Float64(t_2 * (cbrt((t_1 ^ 2.0)) ^ 4.0))));
	elseif (x_46_im <= 1.65e+99)
		tmp = Float64(t_4 * sin(Float64(t_2 * (((cbrt(t_2) ^ 2.0) ^ 3.0) ^ 4.0))));
	else
		tmp = Float64(t_4 * sin((cbrt(fma(y_46_im, t_3, t_0)) ^ 3.0)));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Power[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision] + t$95$0), $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[Power[t$95$1, 1/3], $MachinePrecision]}, Block[{t$95$3 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[Exp[N[(t$95$3 * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$im, -2.6e-162], N[(t$95$4 * N[Sin[N[(t$95$2 * N[Power[N[Power[N[Power[t$95$1, 2.0], $MachinePrecision], 1/3], $MachinePrecision], 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$im, 1.65e+99], N[(t$95$4 * N[Sin[N[(t$95$2 * N[Power[N[Power[N[Power[N[Power[t$95$2, 1/3], $MachinePrecision], 2.0], $MachinePrecision], 3.0], $MachinePrecision], 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$4 * N[Sin[N[Power[N[Power[N[(y$46$im * t$95$3 + t$95$0), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

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

Alternative 2: 79.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sqrt[3]{\sqrt[3]{\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)}}\\ t_2 := \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\\ t_3 := e^{\mathsf{fma}\left(t_2, y.re, \tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)\right)}\\ \mathbf{if}\;x.re \leq -1.3 \cdot 10^{-249}:\\ \;\;\;\;t_3 \cdot \sin \left(t_1 \cdot {t_1}^{8}\right)\\ \mathbf{else}:\\ \;\;\;\;t_3 \cdot \sin \left(\mathsf{fma}\left(t_2, 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 (* y.re (atan2 x.im x.re)))
        (t_1 (cbrt (cbrt (fma y.im (log (hypot x.im x.re)) t_0))))
        (t_2 (log (hypot x.re x.im)))
        (t_3 (exp (fma t_2 y.re (* (atan2 x.im x.re) (- y.im))))))
   (if (<= x.re -1.3e-249)
     (* t_3 (sin (* t_1 (pow t_1 8.0))))
     (* t_3 (sin (fma t_2 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 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = cbrt(cbrt(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)));
	double t_2 = log(hypot(x_46_re, x_46_im));
	double t_3 = exp(fma(t_2, y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im)));
	double tmp;
	if (x_46_re <= -1.3e-249) {
		tmp = t_3 * sin((t_1 * pow(t_1, 8.0)));
	} else {
		tmp = t_3 * sin(fma(t_2, 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(y_46_re * atan(x_46_im, x_46_re))
	t_1 = cbrt(cbrt(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)))
	t_2 = log(hypot(x_46_re, x_46_im))
	t_3 = exp(fma(t_2, y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
	tmp = 0.0
	if (x_46_re <= -1.3e-249)
		tmp = Float64(t_3 * sin(Float64(t_1 * (t_1 ^ 8.0))));
	else
		tmp = Float64(t_3 * sin(fma(t_2, 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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Power[N[Power[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision] + t$95$0), $MachinePrecision], 1/3], $MachinePrecision], 1/3], $MachinePrecision]}, Block[{t$95$2 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[Exp[N[(t$95$2 * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, -1.3e-249], N[(t$95$3 * N[Sin[N[(t$95$1 * N[Power[t$95$1, 8.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$3 * N[Sin[N[(t$95$2 * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

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

Alternative 3: 79.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \log \left(\mathsf{hypot}\left(x.re, x.im\right)\right)\\ t_2 := e^{\mathsf{fma}\left(t_1, y.re, \tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)\right)}\\ \mathbf{if}\;y.re \leq 1.3 \cdot 10^{-53}:\\ \;\;\;\;t_2 \cdot \sin \left(\mathsf{fma}\left(t_1, y.im, t_0\right)\right)\\ \mathbf{elif}\;y.re \leq 5.1 \cdot 10^{+63} \lor \neg \left(y.re \leq 4 \cdot 10^{+188}\right):\\ \;\;\;\;t_2 \cdot \sin \left({\left(\sqrt[3]{\mathsf{fma}\left(y.im, t_1, t_0\right)}\right)}^{3}\right)\\ \mathbf{else}:\\ \;\;\;\;t_2 \cdot \left|\sin \left(\mathsf{fma}\left(y.im, \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right), t_0\right)\right)\right|\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.re (atan2 x.im x.re)))
        (t_1 (log (hypot x.re x.im)))
        (t_2 (exp (fma t_1 y.re (* (atan2 x.im x.re) (- y.im))))))
   (if (<= y.re 1.3e-53)
     (* t_2 (sin (fma t_1 y.im t_0)))
     (if (or (<= y.re 5.1e+63) (not (<= y.re 4e+188)))
       (* t_2 (sin (pow (cbrt (fma y.im t_1 t_0)) 3.0)))
       (* t_2 (fabs (sin (fma y.im (log (hypot x.im x.re)) t_0))))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = log(hypot(x_46_re, x_46_im));
	double t_2 = exp(fma(t_1, y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im)));
	double tmp;
	if (y_46_re <= 1.3e-53) {
		tmp = t_2 * sin(fma(t_1, y_46_im, t_0));
	} else if ((y_46_re <= 5.1e+63) || !(y_46_re <= 4e+188)) {
		tmp = t_2 * sin(pow(cbrt(fma(y_46_im, t_1, t_0)), 3.0));
	} else {
		tmp = t_2 * fabs(sin(fma(y_46_im, log(hypot(x_46_im, x_46_re)), t_0)));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_1 = log(hypot(x_46_re, x_46_im))
	t_2 = exp(fma(t_1, y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
	tmp = 0.0
	if (y_46_re <= 1.3e-53)
		tmp = Float64(t_2 * sin(fma(t_1, y_46_im, t_0)));
	elseif ((y_46_re <= 5.1e+63) || !(y_46_re <= 4e+188))
		tmp = Float64(t_2 * sin((cbrt(fma(y_46_im, t_1, t_0)) ^ 3.0)));
	else
		tmp = Float64(t_2 * abs(sin(fma(y_46_im, log(hypot(x_46_im, x_46_re)), 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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Exp[N[(t$95$1 * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, 1.3e-53], N[(t$95$2 * N[Sin[N[(t$95$1 * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[y$46$re, 5.1e+63], N[Not[LessEqual[y$46$re, 4e+188]], $MachinePrecision]], N[(t$95$2 * N[Sin[N[Power[N[Power[N[(y$46$im * t$95$1 + t$95$0), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$2 * N[Abs[N[Sin[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]]]]]]

Derivation

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

Alternative 4: 79.7% accurate, 0.7× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.re (atan2 x.im x.re))) (t_1 (log (hypot x.re x.im))))
   (if (<= y.re 2.15e+192)
     (*
      (exp (fma t_1 y.re (* (atan2 x.im x.re) (- y.im))))
      (sin (fma t_1 y.im t_0)))
     (*
      (sin (pow (cbrt (fma y.im t_1 t_0)) 3.0))
      (exp (fma t_1 y.re (* (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) {
	double t_0 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = log(hypot(x_46_re, x_46_im));
	double tmp;
	if (y_46_re <= 2.15e+192) {
		tmp = exp(fma(t_1, y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im))) * sin(fma(t_1, y_46_im, t_0));
	} else {
		tmp = sin(pow(cbrt(fma(y_46_im, t_1, t_0)), 3.0)) * exp(fma(t_1, y_46_re, (atan2(x_46_im, x_46_re) * y_46_im)));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_1 = log(hypot(x_46_re, x_46_im))
	tmp = 0.0
	if (y_46_re <= 2.15e+192)
		tmp = Float64(exp(fma(t_1, y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))) * sin(fma(t_1, y_46_im, t_0)));
	else
		tmp = Float64(sin((cbrt(fma(y_46_im, t_1, t_0)) ^ 3.0)) * exp(fma(t_1, y_46_re, Float64(atan(x_46_im, x_46_re) * y_46_im))));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, 2.15e+192], N[(N[Exp[N[(t$95$1 * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$1 * y$46$im + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sin[N[Power[N[Power[N[(y$46$im * t$95$1 + t$95$0), $MachinePrecision], 1/3], $MachinePrecision], 3.0], $MachinePrecision]], $MachinePrecision] * N[Exp[N[(t$95$1 * y$46$re + 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 5: 78.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im}\\ \mathbf{if}\;y.re \leq -2.6:\\ \;\;\;\;t_1 \cdot \sin t_0\\ \mathbf{elif}\;y.re \leq 5.5 \cdot 10^{+58}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right) \cdot \frac{{\left(\mathsf{hypot}\left(x.re, x.im\right)\right)}^{y.re}}{{\left(e^{y.im}\right)}^{\tan^{-1}_* \frac{x.im}{x.re}}}\\ \mathbf{else}:\\ \;\;\;\;t_1 \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.re (atan2 x.im x.re)))
        (t_1
         (exp
          (-
           (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im)))))
           (* (atan2 x.im x.re) y.im)))))
   (if (<= y.re -2.6)
     (* t_1 (sin t_0))
     (if (<= y.re 5.5e+58)
       (*
        (sin (fma (log (hypot x.re x.im)) y.im t_0))
        (/ (pow (hypot x.re x.im) y.re) (pow (exp y.im) (atan2 x.im x.re))))
       (* t_1 (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_re * atan2(x_46_im, x_46_re);
	double t_1 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - (atan2(x_46_im, x_46_re) * y_46_im)));
	double tmp;
	if (y_46_re <= -2.6) {
		tmp = t_1 * sin(t_0);
	} else if (y_46_re <= 5.5e+58) {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * (pow(hypot(x_46_re, x_46_im), y_46_re) / pow(exp(y_46_im), atan2(x_46_im, x_46_re)));
	} else {
		tmp = t_1 * sin((y_46_im * log(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_re * atan(x_46_im, x_46_re))
	t_1 = exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - Float64(atan(x_46_im, x_46_re) * y_46_im)))
	tmp = 0.0
	if (y_46_re <= -2.6)
		tmp = Float64(t_1 * sin(t_0));
	elseif (y_46_re <= 5.5e+58)
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * Float64((hypot(x_46_re, x_46_im) ^ y_46_re) / (exp(y_46_im) ^ atan(x_46_im, x_46_re))));
	else
		tmp = Float64(t_1 * sin(Float64(y_46_im * log(hypot(x_46_im, x_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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -2.6], N[(t$95$1 * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 5.5e+58], 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$re ^ 2 + x$46$im ^ 2], $MachinePrecision], y$46$re], $MachinePrecision] / N[Power[N[Exp[y$46$im], $MachinePrecision], N[ArcTan[x$46$im / x$46$re], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(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]), $MachinePrecision]]]]]

Derivation

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

Alternative 6: 80.2% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (log (hypot x.re x.im))))
   (*
    (exp (fma t_0 y.re (* (atan2 x.im x.re) (- y.im))))
    (sin (fma t_0 y.im (* y.re (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 = log(hypot(x_46_re, x_46_im));
	return exp(fma(t_0, y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im))) * sin(fma(t_0, y_46_im, (y_46_re * atan2(x_46_im, x_46_re))));
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = log(hypot(x_46_re, x_46_im))
	return Float64(exp(fma(t_0, y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))) * sin(fma(t_0, y_46_im, Float64(y_46_re * atan(x_46_im, x_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[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision]}, N[(N[Exp[N[(t$95$0 * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[N[(t$95$0 * y$46$im + N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 7: 73.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right)\\ t_2 := e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im}\\ \mathbf{if}\;y.im \leq -9 \cdot 10^{+189}:\\ \;\;\;\;t_1 \cdot e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{elif}\;y.im \leq -7 \cdot 10^{+22}:\\ \;\;\;\;t_2 \cdot \sin t_0\\ \mathbf{elif}\;y.im \leq 1.7 \cdot 10^{-11}:\\ \;\;\;\;t_1 \cdot {\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re}\\ \mathbf{else}:\\ \;\;\;\;t_2 \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 (* y.re (atan2 x.im x.re)))
        (t_1 (sin (fma (log (hypot x.re x.im)) y.im t_0)))
        (t_2
         (exp
          (-
           (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im)))))
           (* (atan2 x.im x.re) y.im)))))
   (if (<= y.im -9e+189)
     (* t_1 (exp (* (atan2 x.im x.re) (- y.im))))
     (if (<= y.im -7e+22)
       (* t_2 (sin t_0))
       (if (<= y.im 1.7e-11)
         (* t_1 (pow (hypot x.im x.re) y.re))
         (* t_2 (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 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0));
	double t_2 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - (atan2(x_46_im, x_46_re) * y_46_im)));
	double tmp;
	if (y_46_im <= -9e+189) {
		tmp = t_1 * exp((atan2(x_46_im, x_46_re) * -y_46_im));
	} else if (y_46_im <= -7e+22) {
		tmp = t_2 * sin(t_0);
	} else if (y_46_im <= 1.7e-11) {
		tmp = t_1 * pow(hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = t_2 * sin(fabs(t_0));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_1 = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0))
	t_2 = exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - Float64(atan(x_46_im, x_46_re) * y_46_im)))
	tmp = 0.0
	if (y_46_im <= -9e+189)
		tmp = Float64(t_1 * exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))));
	elseif (y_46_im <= -7e+22)
		tmp = Float64(t_2 * sin(t_0));
	elseif (y_46_im <= 1.7e-11)
		tmp = Float64(t_1 * (hypot(x_46_im, x_46_re) ^ y_46_re));
	else
		tmp = Float64(t_2 * 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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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]}, Block[{t$95$2 = 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] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$im, -9e+189], N[(t$95$1 * N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, -7e+22], N[(t$95$2 * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.7e-11], N[(t$95$1 * N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]), $MachinePrecision], N[(t$95$2 * N[Sin[N[Abs[t$95$0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]

Derivation

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

Alternative 8: 78.0% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im}\\ \mathbf{if}\;y.re \leq -0.0105:\\ \;\;\;\;t_1 \cdot \sin t_0\\ \mathbf{elif}\;y.re \leq 1.45 \cdot 10^{-13}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right) \cdot e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{else}:\\ \;\;\;\;t_1 \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.re (atan2 x.im x.re)))
        (t_1
         (exp
          (-
           (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im)))))
           (* (atan2 x.im x.re) y.im)))))
   (if (<= y.re -0.0105)
     (* t_1 (sin t_0))
     (if (<= y.re 1.45e-13)
       (*
        (sin (fma (log (hypot x.re x.im)) y.im t_0))
        (exp (* (atan2 x.im x.re) (- y.im))))
       (* t_1 (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_re * atan2(x_46_im, x_46_re);
	double t_1 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - (atan2(x_46_im, x_46_re) * y_46_im)));
	double tmp;
	if (y_46_re <= -0.0105) {
		tmp = t_1 * sin(t_0);
	} else if (y_46_re <= 1.45e-13) {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * exp((atan2(x_46_im, x_46_re) * -y_46_im));
	} else {
		tmp = t_1 * sin((y_46_im * log(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_re * atan(x_46_im, x_46_re))
	t_1 = exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - Float64(atan(x_46_im, x_46_re) * y_46_im)))
	tmp = 0.0
	if (y_46_re <= -0.0105)
		tmp = Float64(t_1 * sin(t_0));
	elseif (y_46_re <= 1.45e-13)
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0)) * exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))));
	else
		tmp = Float64(t_1 * sin(Float64(y_46_im * log(hypot(x_46_im, x_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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y$46$re, -0.0105], N[(t$95$1 * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.45e-13], 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[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(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]), $MachinePrecision]]]]]

Derivation

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

Alternative 9: 76.7% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_0\right)\right)\\ \mathbf{if}\;y.re \leq -0.00023:\\ \;\;\;\;e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin t_0\\ \mathbf{elif}\;y.re \leq 1.26 \cdot 10^{-5}:\\ \;\;\;\;t_1 \cdot e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{else}:\\ \;\;\;\;t_1 \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 (* y.re (atan2 x.im x.re)))
        (t_1 (sin (fma (log (hypot x.re x.im)) y.im t_0))))
   (if (<= y.re -0.00023)
     (*
      (exp
       (-
        (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im)))))
        (* (atan2 x.im x.re) y.im)))
      (sin t_0))
     (if (<= y.re 1.26e-5)
       (* t_1 (exp (* (atan2 x.im x.re) (- y.im))))
       (* t_1 (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 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0));
	double tmp;
	if (y_46_re <= -0.00023) {
		tmp = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(t_0);
	} else if (y_46_re <= 1.26e-5) {
		tmp = t_1 * exp((atan2(x_46_im, x_46_re) * -y_46_im));
	} else {
		tmp = t_1 * 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(y_46_re * atan(x_46_im, x_46_re))
	t_1 = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_0))
	tmp = 0.0
	if (y_46_re <= -0.00023)
		tmp = Float64(exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(t_0));
	elseif (y_46_re <= 1.26e-5)
		tmp = Float64(t_1 * exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))));
	else
		tmp = Float64(t_1 * (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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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]}, If[LessEqual[y$46$re, -0.00023], 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] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$re, 1.26e-5], N[(t$95$1 * N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$1 * 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 10: 73.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ \mathbf{if}\;y.im \leq -7 \cdot 10^{+22}:\\ \;\;\;\;e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im} \cdot \sin t_0\\ \mathbf{elif}\;y.im \leq 1.5 \cdot 10^{+57}:\\ \;\;\;\;\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}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot {\left(e^{y.im}\right)}^{\left(-\tan^{-1}_* \frac{x.im}{x.re}\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.re (atan2 x.im x.re))))
   (if (<= y.im -7e+22)
     (*
      (exp
       (-
        (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im)))))
        (* (atan2 x.im x.re) y.im)))
      (sin t_0))
     (if (<= y.im 1.5e+57)
       (*
        (sin (fma (log (hypot x.re x.im)) y.im t_0))
        (pow (hypot x.im x.re) y.re))
       (*
        y.re
        (* (atan2 x.im x.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) {
	double t_0 = y_46_re * atan2(x_46_im, x_46_re);
	double tmp;
	if (y_46_im <= -7e+22) {
		tmp = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - (atan2(x_46_im, x_46_re) * y_46_im))) * sin(t_0);
	} else if (y_46_im <= 1.5e+57) {
		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 = y_46_re * (atan2(x_46_im, x_46_re) * pow(exp(y_46_im), -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(y_46_re * atan(x_46_im, x_46_re))
	tmp = 0.0
	if (y_46_im <= -7e+22)
		tmp = Float64(exp(Float64(Float64(y_46_re * log(sqrt(Float64(Float64(x_46_re * x_46_re) + Float64(x_46_im * x_46_im))))) - Float64(atan(x_46_im, x_46_re) * y_46_im))) * sin(t_0));
	elseif (y_46_im <= 1.5e+57)
		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(y_46_re * Float64(atan(x_46_im, x_46_re) * (exp(y_46_im) ^ Float64(-atan(x_46_im, x_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[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y$46$im, -7e+22], 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] - N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * y$46$im), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[y$46$im, 1.5e+57], 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[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * N[Power[N[Exp[y$46$im], $MachinePrecision], (-N[ArcTan[x$46$im / x$46$re], $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 11: 60.4% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\ t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_2 := \sin t_1\\ t_3 := e^{y.re \cdot \log \left(\sqrt{x.re \cdot x.re + x.im \cdot x.im}\right) - t_0} \cdot t_2\\ \mathbf{if}\;x.im \leq -1 \cdot 10^{+65}:\\ \;\;\;\;t_2 \cdot e^{y.re \cdot \log \left(-x.im\right) - t_0}\\ \mathbf{elif}\;x.im \leq 7.2 \cdot 10^{-283}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;x.im \leq 5.2 \cdot 10^{-231}:\\ \;\;\;\;\sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_1\right)\right) \cdot {x.im}^{y.re}\\ \mathbf{elif}\;x.im \leq 0.00165:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;\frac{{x.im}^{y.re}}{e^{t_0}} \cdot \sin \left(t_1 + y.im \cdot \log x.im\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.im))
        (t_1 (* y.re (atan2 x.im x.re)))
        (t_2 (sin t_1))
        (t_3
         (*
          (exp (- (* y.re (log (sqrt (+ (* x.re x.re) (* x.im x.im))))) t_0))
          t_2)))
   (if (<= x.im -1e+65)
     (* t_2 (exp (- (* y.re (log (- x.im))) t_0)))
     (if (<= x.im 7.2e-283)
       t_3
       (if (<= x.im 5.2e-231)
         (* (sin (fma (log (hypot x.re x.im)) y.im t_1)) (pow x.im y.re))
         (if (<= x.im 0.00165)
           t_3
           (*
            (/ (pow x.im y.re) (exp t_0))
            (sin (+ t_1 (* y.im (log x.im)))))))))))

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_im;
	double t_1 = y_46_re * atan2(x_46_im, x_46_re);
	double t_2 = sin(t_1);
	double t_3 = exp(((y_46_re * log(sqrt(((x_46_re * x_46_re) + (x_46_im * x_46_im))))) - t_0)) * t_2;
	double tmp;
	if (x_46_im <= -1e+65) {
		tmp = t_2 * exp(((y_46_re * log(-x_46_im)) - t_0));
	} else if (x_46_im <= 7.2e-283) {
		tmp = t_3;
	} else if (x_46_im <= 5.2e-231) {
		tmp = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_1)) * pow(x_46_im, y_46_re);
	} else if (x_46_im <= 0.00165) {
		tmp = t_3;
	} else {
		tmp = (pow(x_46_im, y_46_re) / exp(t_0)) * sin((t_1 + (y_46_im * log(x_46_im))));
	}
	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_im)
	t_1 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_2 = sin(t_1)
	t_3 = 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)) * t_2)
	tmp = 0.0
	if (x_46_im <= -1e+65)
		tmp = Float64(t_2 * exp(Float64(Float64(y_46_re * log(Float64(-x_46_im))) - t_0)));
	elseif (x_46_im <= 7.2e-283)
		tmp = t_3;
	elseif (x_46_im <= 5.2e-231)
		tmp = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_1)) * (x_46_im ^ y_46_re));
	elseif (x_46_im <= 0.00165)
		tmp = t_3;
	else
		tmp = Float64(Float64((x_46_im ^ y_46_re) / exp(t_0)) * sin(Float64(t_1 + Float64(y_46_im * log(x_46_im)))));
	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$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[t$95$1], $MachinePrecision]}, Block[{t$95$3 = 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] * t$95$2), $MachinePrecision]}, If[LessEqual[x$46$im, -1e+65], N[(t$95$2 * N[Exp[N[(N[(y$46$re * N[Log[(-x$46$im)], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$im, 7.2e-283], t$95$3, If[LessEqual[x$46$im, 5.2e-231], N[(N[Sin[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$im + t$95$1), $MachinePrecision]], $MachinePrecision] * N[Power[x$46$im, y$46$re], $MachinePrecision]), $MachinePrecision], If[LessEqual[x$46$im, 0.00165], t$95$3, N[(N[(N[Power[x$46$im, y$46$re], $MachinePrecision] / N[Exp[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[x$46$im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]]

Derivation

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

Alternative 12: 53.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\ t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_2 := \sin t_1\\ t_3 := t_2 \cdot e^{y.re \cdot \log \left(\left(x.im \cdot \frac{x.im}{x.re}\right) \cdot -0.5 - x.re\right) - t_0}\\ t_4 := \sin \left(\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.im, t_1\right)\right) \cdot {x.im}^{y.re}\\ \mathbf{if}\;x.re \leq -5.8 \cdot 10^{-16}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;x.re \leq -2.6 \cdot 10^{-93}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;x.re \leq -2.75 \cdot 10^{-260}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;x.re \leq 8.2 \cdot 10^{-118}:\\ \;\;\;\;t_4\\ \mathbf{else}:\\ \;\;\;\;t_2 \cdot e^{y.re \cdot \log x.re - t_0}\\ \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.im))
        (t_1 (* y.re (atan2 x.im x.re)))
        (t_2 (sin t_1))
        (t_3
         (*
          t_2
          (exp
           (- (* y.re (log (- (* (* x.im (/ x.im x.re)) -0.5) x.re))) t_0))))
        (t_4 (* (sin (fma (log (hypot x.re x.im)) y.im t_1)) (pow x.im y.re))))
   (if (<= x.re -5.8e-16)
     t_3
     (if (<= x.re -2.6e-93)
       t_4
       (if (<= x.re -2.75e-260)
         t_3
         (if (<= x.re 8.2e-118)
           t_4
           (* t_2 (exp (- (* y.re (log x.re)) 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_im;
	double t_1 = y_46_re * atan2(x_46_im, x_46_re);
	double t_2 = sin(t_1);
	double t_3 = t_2 * exp(((y_46_re * log((((x_46_im * (x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0));
	double t_4 = sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_1)) * pow(x_46_im, y_46_re);
	double tmp;
	if (x_46_re <= -5.8e-16) {
		tmp = t_3;
	} else if (x_46_re <= -2.6e-93) {
		tmp = t_4;
	} else if (x_46_re <= -2.75e-260) {
		tmp = t_3;
	} else if (x_46_re <= 8.2e-118) {
		tmp = t_4;
	} else {
		tmp = t_2 * exp(((y_46_re * log(x_46_re)) - 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_im)
	t_1 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_2 = sin(t_1)
	t_3 = Float64(t_2 * exp(Float64(Float64(y_46_re * log(Float64(Float64(Float64(x_46_im * Float64(x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0)))
	t_4 = Float64(sin(fma(log(hypot(x_46_re, x_46_im)), y_46_im, t_1)) * (x_46_im ^ y_46_re))
	tmp = 0.0
	if (x_46_re <= -5.8e-16)
		tmp = t_3;
	elseif (x_46_re <= -2.6e-93)
		tmp = t_4;
	elseif (x_46_re <= -2.75e-260)
		tmp = t_3;
	elseif (x_46_re <= 8.2e-118)
		tmp = t_4;
	else
		tmp = Float64(t_2 * exp(Float64(Float64(y_46_re * log(x_46_re)) - 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$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[t$95$1], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 * N[Exp[N[(N[(y$46$re * N[Log[N[(N[(N[(x$46$im * N[(x$46$im / x$46$re), $MachinePrecision]), $MachinePrecision] * -0.5), $MachinePrecision] - x$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sin[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$im + t$95$1), $MachinePrecision]], $MachinePrecision] * N[Power[x$46$im, y$46$re], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x$46$re, -5.8e-16], t$95$3, If[LessEqual[x$46$re, -2.6e-93], t$95$4, If[LessEqual[x$46$re, -2.75e-260], t$95$3, If[LessEqual[x$46$re, 8.2e-118], t$95$4, N[(t$95$2 * N[Exp[N[(N[(y$46$re * N[Log[x$46$re], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]]]]

Derivation

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

Alternative 13: 55.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\ t_1 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ \mathbf{if}\;x.im \leq -4 \cdot 10^{-310}:\\ \;\;\;\;\sin t_1 \cdot e^{y.re \cdot \log \left(-x.im\right) - t_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{{x.im}^{y.re}}{e^{t_0}} \cdot \sin \left(t_1 + y.im \cdot \log x.im\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.im)) (t_1 (* y.re (atan2 x.im x.re))))
   (if (<= x.im -4e-310)
     (* (sin t_1) (exp (- (* y.re (log (- x.im))) t_0)))
     (* (/ (pow x.im y.re) (exp t_0)) (sin (+ t_1 (* y.im (log x.im))))))))

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_im;
	double t_1 = y_46_re * atan2(x_46_im, x_46_re);
	double tmp;
	if (x_46_im <= -4e-310) {
		tmp = sin(t_1) * exp(((y_46_re * log(-x_46_im)) - t_0));
	} else {
		tmp = (pow(x_46_im, y_46_re) / exp(t_0)) * sin((t_1 + (y_46_im * log(x_46_im))));
	}
	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) :: t_1
    real(8) :: tmp
    t_0 = atan2(x_46im, x_46re) * y_46im
    t_1 = y_46re * atan2(x_46im, x_46re)
    if (x_46im <= (-4d-310)) then
        tmp = sin(t_1) * exp(((y_46re * log(-x_46im)) - t_0))
    else
        tmp = ((x_46im ** y_46re) / exp(t_0)) * sin((t_1 + (y_46im * log(x_46im))))
    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_im;
	double t_1 = y_46_re * Math.atan2(x_46_im, x_46_re);
	double tmp;
	if (x_46_im <= -4e-310) {
		tmp = Math.sin(t_1) * Math.exp(((y_46_re * Math.log(-x_46_im)) - t_0));
	} else {
		tmp = (Math.pow(x_46_im, y_46_re) / Math.exp(t_0)) * Math.sin((t_1 + (y_46_im * Math.log(x_46_im))));
	}
	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_im
	t_1 = y_46_re * math.atan2(x_46_im, x_46_re)
	tmp = 0
	if x_46_im <= -4e-310:
		tmp = math.sin(t_1) * math.exp(((y_46_re * math.log(-x_46_im)) - t_0))
	else:
		tmp = (math.pow(x_46_im, y_46_re) / math.exp(t_0)) * math.sin((t_1 + (y_46_im * math.log(x_46_im))))
	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_im)
	t_1 = Float64(y_46_re * atan(x_46_im, x_46_re))
	tmp = 0.0
	if (x_46_im <= -4e-310)
		tmp = Float64(sin(t_1) * exp(Float64(Float64(y_46_re * log(Float64(-x_46_im))) - t_0)));
	else
		tmp = Float64(Float64((x_46_im ^ y_46_re) / exp(t_0)) * sin(Float64(t_1 + Float64(y_46_im * log(x_46_im)))));
	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_im;
	t_1 = y_46_re * atan2(x_46_im, x_46_re);
	tmp = 0.0;
	if (x_46_im <= -4e-310)
		tmp = sin(t_1) * exp(((y_46_re * log(-x_46_im)) - t_0));
	else
		tmp = ((x_46_im ^ y_46_re) / exp(t_0)) * sin((t_1 + (y_46_im * log(x_46_im))));
	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$im), $MachinePrecision]}, Block[{t$95$1 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x$46$im, -4e-310], N[(N[Sin[t$95$1], $MachinePrecision] * N[Exp[N[(N[(y$46$re * N[Log[(-x$46$im)], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[x$46$im, y$46$re], $MachinePrecision] / N[Exp[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(t$95$1 + N[(y$46$im * N[Log[x$46$im], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 14: 56.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \tan^{-1}_* \frac{x.im}{x.re} \cdot y.im\\ t_1 := \sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\ \mathbf{if}\;x.re \leq -5 \cdot 10^{-310}:\\ \;\;\;\;t_1 \cdot e^{y.re \cdot \log \left(\left(x.im \cdot \frac{x.im}{x.re}\right) \cdot -0.5 - x.re\right) - t_0}\\ \mathbf{else}:\\ \;\;\;\;t_1 \cdot e^{y.re \cdot \log x.re - t_0}\\ \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.im))
        (t_1 (sin (* y.re (atan2 x.im x.re)))))
   (if (<= x.re -5e-310)
     (*
      t_1
      (exp (- (* y.re (log (- (* (* x.im (/ x.im x.re)) -0.5) x.re))) t_0)))
     (* t_1 (exp (- (* y.re (log x.re)) 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_im;
	double t_1 = sin((y_46_re * atan2(x_46_im, x_46_re)));
	double tmp;
	if (x_46_re <= -5e-310) {
		tmp = t_1 * exp(((y_46_re * log((((x_46_im * (x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0));
	} else {
		tmp = t_1 * exp(((y_46_re * log(x_46_re)) - t_0));
	}
	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) :: t_1
    real(8) :: tmp
    t_0 = atan2(x_46im, x_46re) * y_46im
    t_1 = sin((y_46re * atan2(x_46im, x_46re)))
    if (x_46re <= (-5d-310)) then
        tmp = t_1 * exp(((y_46re * log((((x_46im * (x_46im / x_46re)) * (-0.5d0)) - x_46re))) - t_0))
    else
        tmp = t_1 * exp(((y_46re * log(x_46re)) - t_0))
    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_im;
	double t_1 = Math.sin((y_46_re * Math.atan2(x_46_im, x_46_re)));
	double tmp;
	if (x_46_re <= -5e-310) {
		tmp = t_1 * Math.exp(((y_46_re * Math.log((((x_46_im * (x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0));
	} else {
		tmp = t_1 * Math.exp(((y_46_re * Math.log(x_46_re)) - t_0));
	}
	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_im
	t_1 = math.sin((y_46_re * math.atan2(x_46_im, x_46_re)))
	tmp = 0
	if x_46_re <= -5e-310:
		tmp = t_1 * math.exp(((y_46_re * math.log((((x_46_im * (x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0))
	else:
		tmp = t_1 * math.exp(((y_46_re * math.log(x_46_re)) - 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_im)
	t_1 = sin(Float64(y_46_re * atan(x_46_im, x_46_re)))
	tmp = 0.0
	if (x_46_re <= -5e-310)
		tmp = Float64(t_1 * exp(Float64(Float64(y_46_re * log(Float64(Float64(Float64(x_46_im * Float64(x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0)));
	else
		tmp = Float64(t_1 * exp(Float64(Float64(y_46_re * log(x_46_re)) - t_0)));
	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_im;
	t_1 = sin((y_46_re * atan2(x_46_im, x_46_re)));
	tmp = 0.0;
	if (x_46_re <= -5e-310)
		tmp = t_1 * exp(((y_46_re * log((((x_46_im * (x_46_im / x_46_re)) * -0.5) - x_46_re))) - t_0));
	else
		tmp = t_1 * exp(((y_46_re * log(x_46_re)) - t_0));
	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$im), $MachinePrecision]}, Block[{t$95$1 = N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, -5e-310], N[(t$95$1 * N[Exp[N[(N[(y$46$re * N[Log[N[(N[(N[(x$46$im * N[(x$46$im / x$46$re), $MachinePrecision]), $MachinePrecision] * -0.5), $MachinePrecision] - x$46$re), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[Exp[N[(N[(y$46$re * N[Log[x$46$re], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 15: 58.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.im \leq -4.4 \cdot 10^{+54}:\\ \;\;\;\;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)\\ \mathbf{elif}\;y.im \leq 1.7 \cdot 10^{+49}:\\ \;\;\;\;\sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right) \cdot {\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re}\\ \mathbf{else}:\\ \;\;\;\;y.re \cdot \left(\tan^{-1}_* \frac{x.im}{x.re} \cdot {\left(e^{y.im}\right)}^{\left(-\tan^{-1}_* \frac{x.im}{x.re}\right)}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (if (<= y.im -4.4e+54)
   (* y.re (* (atan2 x.im x.re) (exp (* (atan2 x.im x.re) (- y.im)))))
   (if (<= y.im 1.7e+49)
     (* (sin (* y.re (atan2 x.im x.re))) (pow (hypot x.im x.re) y.re))
     (* y.re (* (atan2 x.im x.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) {
	double tmp;
	if (y_46_im <= -4.4e+54) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	} else if (y_46_im <= 1.7e+49) {
		tmp = sin((y_46_re * atan2(x_46_im, x_46_re))) * pow(hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * pow(exp(y_46_im), -atan2(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 tmp;
	if (y_46_im <= -4.4e+54) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)));
	} else if (y_46_im <= 1.7e+49) {
		tmp = Math.sin((y_46_re * Math.atan2(x_46_im, x_46_re))) * Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * 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):
	tmp = 0
	if y_46_im <= -4.4e+54:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)))
	elif y_46_im <= 1.7e+49:
		tmp = math.sin((y_46_re * math.atan2(x_46_im, x_46_re))) * math.pow(math.hypot(x_46_im, x_46_re), y_46_re)
	else:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * 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)
	tmp = 0.0
	if (y_46_im <= -4.4e+54)
		tmp = 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)))));
	elseif (y_46_im <= 1.7e+49)
		tmp = Float64(sin(Float64(y_46_re * atan(x_46_im, x_46_re))) * (hypot(x_46_im, x_46_re) ^ y_46_re));
	else
		tmp = Float64(y_46_re * Float64(atan(x_46_im, x_46_re) * (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)
	tmp = 0.0;
	if (y_46_im <= -4.4e+54)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	elseif (y_46_im <= 1.7e+49)
		tmp = sin((y_46_re * atan2(x_46_im, x_46_re))) * (hypot(x_46_im, x_46_re) ^ y_46_re);
	else
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * (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_] := If[LessEqual[y$46$im, -4.4e+54], 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], If[LessEqual[y$46$im, 1.7e+49], N[(N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]), $MachinePrecision], N[(y$46$re * N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * N[Power[N[Exp[y$46$im], $MachinePrecision], (-N[ArcTan[x$46$im / x$46$re], $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 16: 57.7% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.im \leq -4.4 \cdot 10^{+54} \lor \neg \left(y.im \leq 5.3 \cdot 10^{+48}\right):\\ \;\;\;\;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)\\ \mathbf{else}:\\ \;\;\;\;\sin \left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\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
 (if (or (<= y.im -4.4e+54) (not (<= y.im 5.3e+48)))
   (* y.re (* (atan2 x.im x.re) (exp (* (atan2 x.im x.re) (- y.im)))))
   (* (sin (* y.re (atan2 x.im x.re))) (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 tmp;
	if ((y_46_im <= -4.4e+54) || !(y_46_im <= 5.3e+48)) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = sin((y_46_re * atan2(x_46_im, x_46_re))) * pow(hypot(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 tmp;
	if ((y_46_im <= -4.4e+54) || !(y_46_im <= 5.3e+48)) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = Math.sin((y_46_re * Math.atan2(x_46_im, x_46_re))) * Math.pow(Math.hypot(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):
	tmp = 0
	if (y_46_im <= -4.4e+54) or not (y_46_im <= 5.3e+48):
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)))
	else:
		tmp = math.sin((y_46_re * math.atan2(x_46_im, x_46_re))) * math.pow(math.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)
	tmp = 0.0
	if ((y_46_im <= -4.4e+54) || !(y_46_im <= 5.3e+48))
		tmp = 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)))));
	else
		tmp = Float64(sin(Float64(y_46_re * atan(x_46_im, x_46_re))) * (hypot(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)
	tmp = 0.0;
	if ((y_46_im <= -4.4e+54) || ~((y_46_im <= 5.3e+48)))
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	else
		tmp = sin((y_46_re * atan2(x_46_im, x_46_re))) * (hypot(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_] := If[Or[LessEqual[y$46$im, -4.4e+54], N[Not[LessEqual[y$46$im, 5.3e+48]], $MachinePrecision]], 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], N[(N[Sin[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $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 17: 42.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.re \leq 4.2 \cdot 10^{+82}:\\ \;\;\;\;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)\\ \mathbf{else}:\\ \;\;\;\;\log \left({\left(e^{y.re}\right)}^{\tan^{-1}_* \frac{x.im}{x.re}}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (if (<= y.re 4.2e+82)
   (* y.re (* (atan2 x.im x.re) (exp (* (atan2 x.im x.re) (- y.im)))))
   (log (pow (exp y.re) (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 tmp;
	if (y_46_re <= 4.2e+82) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = log(pow(exp(y_46_re), 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) :: tmp
    if (y_46re <= 4.2d+82) then
        tmp = y_46re * (atan2(x_46im, x_46re) * exp((atan2(x_46im, x_46re) * -y_46im)))
    else
        tmp = log((exp(y_46re) ** 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 tmp;
	if (y_46_re <= 4.2e+82) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = Math.log(Math.pow(Math.exp(y_46_re), 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):
	tmp = 0
	if y_46_re <= 4.2e+82:
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)))
	else:
		tmp = math.log(math.pow(math.exp(y_46_re), 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)
	tmp = 0.0
	if (y_46_re <= 4.2e+82)
		tmp = 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)))));
	else
		tmp = log((exp(y_46_re) ^ 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)
	tmp = 0.0;
	if (y_46_re <= 4.2e+82)
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	else
		tmp = log((exp(y_46_re) ^ 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_] := If[LessEqual[y$46$re, 4.2e+82], 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], N[Log[N[Power[N[Exp[y$46$re], $MachinePrecision], N[ArcTan[x$46$im / x$46$re], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]]

Derivation

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

Alternative 18: 43.9% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.im \leq -2.5 \cdot 10^{-30} \lor \neg \left(y.im \leq 3.5 \cdot 10^{+20}\right):\\ \;\;\;\;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)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{log1p}\left(\mathsf{expm1}\left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (if (or (<= y.im -2.5e-30) (not (<= y.im 3.5e+20)))
   (* y.re (* (atan2 x.im x.re) (exp (* (atan2 x.im x.re) (- y.im)))))
   (log1p (expm1 (* y.re (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 tmp;
	if ((y_46_im <= -2.5e-30) || !(y_46_im <= 3.5e+20)) {
		tmp = y_46_re * (atan2(x_46_im, x_46_re) * exp((atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = log1p(expm1((y_46_re * atan2(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 tmp;
	if ((y_46_im <= -2.5e-30) || !(y_46_im <= 3.5e+20)) {
		tmp = y_46_re * (Math.atan2(x_46_im, x_46_re) * Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im)));
	} else {
		tmp = Math.log1p(Math.expm1((y_46_re * 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):
	tmp = 0
	if (y_46_im <= -2.5e-30) or not (y_46_im <= 3.5e+20):
		tmp = y_46_re * (math.atan2(x_46_im, x_46_re) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im)))
	else:
		tmp = math.log1p(math.expm1((y_46_re * 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)
	tmp = 0.0
	if ((y_46_im <= -2.5e-30) || !(y_46_im <= 3.5e+20))
		tmp = 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)))));
	else
		tmp = log1p(expm1(Float64(y_46_re * atan(x_46_im, x_46_re))));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$im, -2.5e-30], N[Not[LessEqual[y$46$im, 3.5e+20]], $MachinePrecision]], 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], N[Log[1 + N[(Exp[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]], $MachinePrecision]]

Derivation

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

Alternative 19: 33.1% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \mathsf{expm1}\left(y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\right)\\ \mathbf{if}\;y.im \leq -2.9 \cdot 10^{-46} \lor \neg \left(y.im \leq 4.6 \cdot 10^{-151}\right):\\ \;\;\;\;\log \left(1 + t_0\right)\\ \mathbf{else}:\\ \;\;\;\;\mathsf{log1p}\left(t_0\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (expm1 (* y.re (atan2 x.im x.re)))))
   (if (or (<= y.im -2.9e-46) (not (<= y.im 4.6e-151)))
     (log (+ 1.0 t_0))
     (log1p t_0))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = expm1((y_46_re * atan2(x_46_im, x_46_re)));
	double tmp;
	if ((y_46_im <= -2.9e-46) || !(y_46_im <= 4.6e-151)) {
		tmp = log((1.0 + t_0));
	} else {
		tmp = log1p(t_0);
	}
	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.expm1((y_46_re * Math.atan2(x_46_im, x_46_re)));
	double tmp;
	if ((y_46_im <= -2.9e-46) || !(y_46_im <= 4.6e-151)) {
		tmp = Math.log((1.0 + t_0));
	} else {
		tmp = Math.log1p(t_0);
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = math.expm1((y_46_re * math.atan2(x_46_im, x_46_re)))
	tmp = 0
	if (y_46_im <= -2.9e-46) or not (y_46_im <= 4.6e-151):
		tmp = math.log((1.0 + t_0))
	else:
		tmp = math.log1p(t_0)
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = expm1(Float64(y_46_re * atan(x_46_im, x_46_re)))
	tmp = 0.0
	if ((y_46_im <= -2.9e-46) || !(y_46_im <= 4.6e-151))
		tmp = log(Float64(1.0 + t_0));
	else
		tmp = log1p(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[(Exp[N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]] - 1), $MachinePrecision]}, If[Or[LessEqual[y$46$im, -2.9e-46], N[Not[LessEqual[y$46$im, 4.6e-151]], $MachinePrecision]], N[Log[N[(1.0 + t$95$0), $MachinePrecision]], $MachinePrecision], N[Log[1 + t$95$0], $MachinePrecision]]]

Derivation

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

Alternative 20: 29.9% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y.re \cdot \tan^{-1}_* \frac{x.im}{x.re}\\ t_1 := \mathsf{expm1}\left(t_0\right)\\ \mathbf{if}\;y.im \leq -1.8 \cdot 10^{-30}:\\ \;\;\;\;{\left({t_0}^{3}\right)}^{0.3333333333333333}\\ \mathbf{elif}\;y.im \leq 1.8 \cdot 10^{-150}:\\ \;\;\;\;\mathsf{log1p}\left(t_1\right)\\ \mathbf{else}:\\ \;\;\;\;\log \left(1 + t_1\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (* y.re (atan2 x.im x.re))) (t_1 (expm1 t_0)))
   (if (<= y.im -1.8e-30)
     (pow (pow t_0 3.0) 0.3333333333333333)
     (if (<= y.im 1.8e-150) (log1p t_1) (log (+ 1.0 t_1))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = y_46_re * atan2(x_46_im, x_46_re);
	double t_1 = expm1(t_0);
	double tmp;
	if (y_46_im <= -1.8e-30) {
		tmp = pow(pow(t_0, 3.0), 0.3333333333333333);
	} else if (y_46_im <= 1.8e-150) {
		tmp = log1p(t_1);
	} else {
		tmp = log((1.0 + 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 = y_46_re * Math.atan2(x_46_im, x_46_re);
	double t_1 = Math.expm1(t_0);
	double tmp;
	if (y_46_im <= -1.8e-30) {
		tmp = Math.pow(Math.pow(t_0, 3.0), 0.3333333333333333);
	} else if (y_46_im <= 1.8e-150) {
		tmp = Math.log1p(t_1);
	} else {
		tmp = Math.log((1.0 + t_1));
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	t_0 = y_46_re * math.atan2(x_46_im, x_46_re)
	t_1 = math.expm1(t_0)
	tmp = 0
	if y_46_im <= -1.8e-30:
		tmp = math.pow(math.pow(t_0, 3.0), 0.3333333333333333)
	elif y_46_im <= 1.8e-150:
		tmp = math.log1p(t_1)
	else:
		tmp = math.log((1.0 + t_1))
	return tmp

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = Float64(y_46_re * atan(x_46_im, x_46_re))
	t_1 = expm1(t_0)
	tmp = 0.0
	if (y_46_im <= -1.8e-30)
		tmp = (t_0 ^ 3.0) ^ 0.3333333333333333;
	elseif (y_46_im <= 1.8e-150)
		tmp = log1p(t_1);
	else
		tmp = log(Float64(1.0 + t_1));
	end
	return tmp
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := Block[{t$95$0 = N[(y$46$re * N[ArcTan[x$46$im / x$46$re], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Exp[t$95$0] - 1), $MachinePrecision]}, If[LessEqual[y$46$im, -1.8e-30], N[Power[N[Power[t$95$0, 3.0], $MachinePrecision], 0.3333333333333333], $MachinePrecision], If[LessEqual[y$46$im, 1.8e-150], N[Log[1 + t$95$1], $MachinePrecision], N[Log[N[(1.0 + t$95$1), $MachinePrecision]], $MachinePrecision]]]]]

Derivation

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

Alternative 21: 23.3% accurate, 2.7× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (log1p (expm1 (* y.re (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 log1p(expm1((y_46_re * atan2(x_46_im, x_46_re))));
}

Java

public static double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return Math.log1p(Math.expm1((y_46_re * 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.log1p(math.expm1((y_46_re * math.atan2(x_46_im, x_46_re))))

Julia

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

Wolfram

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

Derivation

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

Alternative 22: 14.0% accurate, 8.0× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im) :precision binary64 (* y.re (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 y_46_re * 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 = y_46re * 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 y_46_re * Math.atan2(x_46_im, x_46_re);
}

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)

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(y_46_re * 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 = y_46_re * atan2(x_46_im, x_46_re);
end

Wolfram

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

Derivation

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

Reproduce

herbie shell --seed 2023350 
(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)))))