powComplex, real part

Percentage Accurate: 40.0% → 80.5%

Time: 25.1s

Alternatives: 10

Speedup: 4.1×

• 36.3% 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 \cos \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)))
    (cos (+ (* 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))) * cos(((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))) * cos(((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.cos(((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.cos(((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))) * cos(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))) * cos(((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[Cos[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.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 \cos \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)))
    (cos (+ (* 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))) * cos(((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))) * cos(((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.cos(((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.cos(((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))) * cos(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))) * cos(((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[Cos[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: 80.5% accurate, 1.2× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0
         (exp
          (fma (log (hypot x.re x.im)) y.re (* (atan2 x.im x.re) (- y.im))))))
   (if (<= x.re 3.5e-209) t_0 (* t_0 (cos (* y.im (log x.re)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im)));
	double tmp;
	if (x_46_re <= 3.5e-209) {
		tmp = t_0;
	} else {
		tmp = t_0 * cos((y_46_im * log(x_46_re)));
	}
	return tmp;
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
	tmp = 0.0
	if (x_46_re <= 3.5e-209)
		tmp = t_0;
	else
		tmp = Float64(t_0 * cos(Float64(y_46_im * log(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[Exp[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$re, 3.5e-209], t$95$0, N[(t$95$0 * N[Cos[N[(y$46$im * N[Log[x$46$re], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 2: 81.9% accurate, 0.4× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (let* ((t_0 (exp (cos (* y.im (log (hypot x.im x.re)))))) (t_1 (+ 1.0 t_0)))
   (*
    (exp (fma (log (hypot x.re x.im)) y.re (* (atan2 x.im x.re) (- y.im))))
    (- (log (+ (pow t_1 3.0) -1.0)) (log (+ (pow t_1 2.0) (+ t_0 2.0)))))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	double t_0 = exp(cos((y_46_im * log(hypot(x_46_im, x_46_re)))));
	double t_1 = 1.0 + t_0;
	return exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im))) * (log((pow(t_1, 3.0) + -1.0)) - log((pow(t_1, 2.0) + (t_0 + 2.0))));
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	t_0 = exp(cos(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))))
	t_1 = Float64(1.0 + t_0)
	return Float64(exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))) * Float64(log(Float64((t_1 ^ 3.0) + -1.0)) - log(Float64((t_1 ^ 2.0) + Float64(t_0 + 2.0)))))
end

Wolfram

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

Derivation

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

Alternative 3: 81.9% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (*
  (exp (fma (log (hypot x.re x.im)) y.re (* (atan2 x.im x.re) (- y.im))))
  (log (+ (+ 1.0 (exp (cos (* y.im (log (hypot x.im x.re)))))) -1.0))))

C

double code(double x_46_re, double x_46_im, double y_46_re, double y_46_im) {
	return exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im))) * log(((1.0 + exp(cos((y_46_im * log(hypot(x_46_im, x_46_re)))))) + -1.0));
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))) * log(Float64(Float64(1.0 + exp(cos(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))))) + -1.0)))
end

Wolfram

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

Derivation

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

Alternative 4: 81.9% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (*
  (exp (fma (log (hypot x.re x.im)) y.re (* (atan2 x.im x.re) (- y.im))))
  (log (+ 1.0 (expm1 (cos (* 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) {
	return exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im))) * log((1.0 + expm1(cos((y_46_im * log(hypot(x_46_im, x_46_re)))))));
}

Julia

function code(x_46_re, x_46_im, y_46_re, y_46_im)
	return Float64(exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)))) * log(Float64(1.0 + expm1(cos(Float64(y_46_im * log(hypot(x_46_im, x_46_re))))))))
end

Wolfram

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

Derivation

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

Alternative 5: 81.9% accurate, 1.0× speedup

Math

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

FPCore

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

Julia

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

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := N[(N[Exp[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Cos[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: 81.0% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.re, \tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)\right)}\\ \mathbf{if}\;x.im \leq 8.5 \cdot 10^{-299}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_0 \cdot \cos \left(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
         (exp
          (fma (log (hypot x.re x.im)) y.re (* (atan2 x.im x.re) (- y.im))))))
   (if (<= x.im 8.5e-299) t_0 (* t_0 (cos (* 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 = exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (atan2(x_46_im, x_46_re) * -y_46_im)));
	double tmp;
	if (x_46_im <= 8.5e-299) {
		tmp = t_0;
	} else {
		tmp = t_0 * cos((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 = exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
	tmp = 0.0
	if (x_46_im <= 8.5e-299)
		tmp = t_0;
	else
		tmp = Float64(t_0 * cos(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[Exp[N[(N[Log[N[Sqrt[x$46$re ^ 2 + x$46$im ^ 2], $MachinePrecision]], $MachinePrecision] * y$46$re + N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[x$46$im, 8.5e-299], t$95$0, N[(t$95$0 * N[Cos[N[(y$46$im * N[Log[x$46$im], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 76.2% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.re \leq -2.35 \cdot 10^{-30}:\\ \;\;\;\;{\left(\sqrt{{x.im}^{2} + {x.re}^{2}}\right)}^{y.re}\\ \mathbf{elif}\;y.re \leq 7.2 \cdot 10^{+29}:\\ \;\;\;\;\cos \left(y.im \cdot \log \left(\mathsf{hypot}\left(x.im, x.re\right)\right)\right) \cdot e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \mathbf{else}:\\ \;\;\;\;{\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 (<= y.re -2.35e-30)
   (pow (sqrt (+ (pow x.im 2.0) (pow x.re 2.0))) y.re)
   (if (<= y.re 7.2e+29)
     (*
      (cos (* y.im (log (hypot x.im x.re))))
      (exp (* (atan2 x.im x.re) (- y.im))))
     (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_re <= -2.35e-30) {
		tmp = pow(sqrt((pow(x_46_im, 2.0) + pow(x_46_re, 2.0))), y_46_re);
	} else if (y_46_re <= 7.2e+29) {
		tmp = cos((y_46_im * log(hypot(x_46_im, x_46_re)))) * exp((atan2(x_46_im, x_46_re) * -y_46_im));
	} else {
		tmp = 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_re <= -2.35e-30) {
		tmp = Math.pow(Math.sqrt((Math.pow(x_46_im, 2.0) + Math.pow(x_46_re, 2.0))), y_46_re);
	} else if (y_46_re <= 7.2e+29) {
		tmp = Math.cos((y_46_im * Math.log(Math.hypot(x_46_im, x_46_re)))) * Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	} else {
		tmp = 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_re <= -2.35e-30:
		tmp = math.pow(math.sqrt((math.pow(x_46_im, 2.0) + math.pow(x_46_re, 2.0))), y_46_re)
	elif y_46_re <= 7.2e+29:
		tmp = math.cos((y_46_im * math.log(math.hypot(x_46_im, x_46_re)))) * math.exp((math.atan2(x_46_im, x_46_re) * -y_46_im))
	else:
		tmp = 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_re <= -2.35e-30)
		tmp = sqrt(Float64((x_46_im ^ 2.0) + (x_46_re ^ 2.0))) ^ y_46_re;
	elseif (y_46_re <= 7.2e+29)
		tmp = Float64(cos(Float64(y_46_im * log(hypot(x_46_im, x_46_re)))) * exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))));
	else
		tmp = 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_re <= -2.35e-30)
		tmp = sqrt(((x_46_im ^ 2.0) + (x_46_re ^ 2.0))) ^ y_46_re;
	elseif (y_46_re <= 7.2e+29)
		tmp = cos((y_46_im * log(hypot(x_46_im, x_46_re)))) * exp((atan2(x_46_im, x_46_re) * -y_46_im));
	else
		tmp = 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[LessEqual[y$46$re, -2.35e-30], N[Power[N[Sqrt[N[(N[Power[x$46$im, 2.0], $MachinePrecision] + N[Power[x$46$re, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], y$46$re], $MachinePrecision], If[LessEqual[y$46$re, 7.2e+29], N[(N[Cos[N[(y$46$im * N[Log[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]]]

Derivation

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

Alternative 8: 80.7% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ e^{\mathsf{fma}\left(\log \left(\mathsf{hypot}\left(x.re, x.im\right)\right), y.re, \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
 (exp (fma (log (hypot x.re x.im)) 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) {
	return exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, (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 exp(fma(log(hypot(x_46_re, x_46_im)), y_46_re, Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im))))
end

Wolfram

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

Derivation

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

Alternative 9: 75.1% accurate, 4.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y.re \leq -2.2 \cdot 10^{+49} \lor \neg \left(y.re \leq 1500\right):\\ \;\;\;\;{\left(\mathsf{hypot}\left(x.im, x.re\right)\right)}^{y.re}\\ \mathbf{else}:\\ \;\;\;\;e^{\tan^{-1}_* \frac{x.im}{x.re} \cdot \left(-y.im\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im y.re y.im)
 :precision binary64
 (if (or (<= y.re -2.2e+49) (not (<= y.re 1500.0)))
   (pow (hypot x.im x.re) y.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) {
	double tmp;
	if ((y_46_re <= -2.2e+49) || !(y_46_re <= 1500.0)) {
		tmp = pow(hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	}
	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_re <= -2.2e+49) || !(y_46_re <= 1500.0)) {
		tmp = Math.pow(Math.hypot(x_46_im, x_46_re), y_46_re);
	} else {
		tmp = Math.exp((Math.atan2(x_46_im, x_46_re) * -y_46_im));
	}
	return tmp;
}

Python

def code(x_46_re, x_46_im, y_46_re, y_46_im):
	tmp = 0
	if (y_46_re <= -2.2e+49) or not (y_46_re <= 1500.0):
		tmp = math.pow(math.hypot(x_46_im, x_46_re), y_46_re)
	else:
		tmp = math.exp((math.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)
	tmp = 0.0
	if ((y_46_re <= -2.2e+49) || !(y_46_re <= 1500.0))
		tmp = hypot(x_46_im, x_46_re) ^ y_46_re;
	else
		tmp = exp(Float64(atan(x_46_im, x_46_re) * Float64(-y_46_im)));
	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 <= -2.2e+49) || ~((y_46_re <= 1500.0)))
		tmp = hypot(x_46_im, x_46_re) ^ y_46_re;
	else
		tmp = exp((atan2(x_46_im, x_46_re) * -y_46_im));
	end
	tmp_2 = tmp;
end

Wolfram

code[x$46$re_, x$46$im_, y$46$re_, y$46$im_] := If[Or[LessEqual[y$46$re, -2.2e+49], N[Not[LessEqual[y$46$re, 1500.0]], $MachinePrecision]], N[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision], N[Exp[N[(N[ArcTan[x$46$im / x$46$re], $MachinePrecision] * (-y$46$im)), $MachinePrecision]], $MachinePrecision]]

Derivation

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

Alternative 10: 62.2% accurate, 4.1× speedup

Math

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

FPCore

(FPCore (x.re x.im y.re y.im) :precision binary64 (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) {
	return pow(hypot(x_46_im, x_46_re), y_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.pow(Math.hypot(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.pow(math.hypot(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 hypot(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 = hypot(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[Power[N[Sqrt[x$46$im ^ 2 + x$46$re ^ 2], $MachinePrecision], y$46$re], $MachinePrecision]

Derivation

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

Reproduce

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