math.square on complex, imaginary part

Percentage Accurate: 100.0% → 100.0%

Time: 1.2s

Alternatives: 3

Speedup: N/A×

Specification

Math

\[\begin{array}{l} \\ re \cdot im + im \cdot re \end{array} \]

FPCore

(FPCore im_sqr (re im) :precision binary64 (+ (* re im) (* im re)))

C

double im_sqr(double re, double im) {
	return (re * im) + (im * re);
}

Fortran

real(8) function im_sqr(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    im_sqr = (re * im) + (im * re)
end function

Java

public static double im_sqr(double re, double im) {
	return (re * im) + (im * re);
}

Python

def im_sqr(re, im):
	return (re * im) + (im * re)

Julia

function im_sqr(re, im)
	return Float64(Float64(re * im) + Float64(im * re))
end

MATLAB

function tmp = im_sqr(re, im)
	tmp = (re * im) + (im * re);
end

Wolfram

im$95$sqr[re_, im_] := N[(N[(re * im), $MachinePrecision] + N[(im * re), $MachinePrecision]), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ re \cdot im + im \cdot re \end{array} \]

FPCore

(FPCore im_sqr (re im) :precision binary64 (+ (* re im) (* im re)))

C

double im_sqr(double re, double im) {
	return (re * im) + (im * re);
}

Fortran

real(8) function im_sqr(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    im_sqr = (re * im) + (im * re)
end function

Java

public static double im_sqr(double re, double im) {
	return (re * im) + (im * re);
}

Python

def im_sqr(re, im):
	return (re * im) + (im * re)

Julia

function im_sqr(re, im)
	return Float64(Float64(re * im) + Float64(im * re))
end

MATLAB

function tmp = im_sqr(re, im)
	tmp = (re * im) + (im * re);
end

Wolfram

im$95$sqr[re_, im_] := N[(N[(re * im), $MachinePrecision] + N[(im * re), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} re\_m = \left|re\right| \\ re\_s = \mathsf{copysign}\left(1, re\right) \\ [re_m, im] = \mathsf{sort}([re_m, im])\\ \\ re\_s \cdot \left(\left(re\_m \cdot 2\right) \cdot im\right) \end{array} \]

FPCore

re\_m = (fabs.f64 re)
re\_s = (copysign.f64 #s(literal 1 binary64) re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re_s re_m im) :precision binary64 (* re_s (* (* re_m 2.0) im)))

C

re\_m = fabs(re);
re\_s = copysign(1.0, re);
assert(re_m < im);
double im_sqr(double re_s, double re_m, double im) {
	return re_s * ((re_m * 2.0) * im);
}

Fortran

re\_m = abs(re)
re\_s = copysign(1.0d0, re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re_s, re_m, im)
    real(8), intent (in) :: re_s
    real(8), intent (in) :: re_m
    real(8), intent (in) :: im
    im_sqr = re_s * ((re_m * 2.0d0) * im)
end function

Java

re\_m = Math.abs(re);
re\_s = Math.copySign(1.0, re);
assert re_m < im;
public static double im_sqr(double re_s, double re_m, double im) {
	return re_s * ((re_m * 2.0) * im);
}

Python

re\_m = math.fabs(re)
re\_s = math.copysign(1.0, re)
[re_m, im] = sort([re_m, im])
def im_sqr(re_s, re_m, im):
	return re_s * ((re_m * 2.0) * im)

Julia

re\_m = abs(re)
re\_s = copysign(1.0, re)
re_m, im = sort([re_m, im])
function im_sqr(re_s, re_m, im)
	return Float64(re_s * Float64(Float64(re_m * 2.0) * im))
end

MATLAB

re\_m = abs(re);
re\_s = sign(re) * abs(1.0);
re_m, im = num2cell(sort([re_m, im])){:}
function tmp = im_sqr(re_s, re_m, im)
	tmp = re_s * ((re_m * 2.0) * im);
end

Wolfram

re\_m = N[Abs[re], $MachinePrecision]
re\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[re]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: re_m and im should be sorted in increasing order before calling this function.
im$95$sqr[re$95$s_, re$95$m_, im_] := N[(re$95$s * N[(N[(re$95$m * 2.0), $MachinePrecision] * im), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[re \cdot im + im \cdot re \]
2. Step-by-step derivation

   1. *-commutative N/A

      \[\leadsto re \cdot im + re \cdot \color{blue}{im} \]

   2. distribute-lft-out N/A

      \[\leadsto re \cdot \color{blue}{\left(im + im\right)} \]

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

      \[\leadsto \mathsf{*.f64}\left(re, \color{blue}{\left(im + im\right)}\right) \]

   4. count-2 N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(2 \cdot \color{blue}{im}\right)\right) \]

   5. *-commutative N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(im \cdot \color{blue}{2}\right)\right) \]

   6. *-lowering-*.f64 100.0%

      \[\leadsto \mathsf{*.f64}\left(re, \mathsf{*.f64}\left(im, \color{blue}{2}\right)\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{re \cdot \left(im \cdot 2\right)} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. *-commutative N/A

      \[\leadsto re \cdot \left(2 \cdot \color{blue}{im}\right) \]

   2. associate-*r* N/A

      \[\leadsto \left(re \cdot 2\right) \cdot \color{blue}{im} \]

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

      \[\leadsto \mathsf{*.f64}\left(\left(re \cdot 2\right), \color{blue}{im}\right) \]

   4. *-lowering-*.f64 99.6%

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(re, 2\right), im\right) \]

6. Applied egg-rr 99.6%

   \[\leadsto \color{blue}{\left(re \cdot 2\right) \cdot im} \]
7. Add Preprocessing

Alternative 2: 100.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} re\_m = \left|re\right| \\ re\_s = \mathsf{copysign}\left(1, re\right) \\ [re_m, im] = \mathsf{sort}([re_m, im])\\ \\ re\_s \cdot \left(re\_m \cdot \left(2 \cdot im\right)\right) \end{array} \]

FPCore

re\_m = (fabs.f64 re)
re\_s = (copysign.f64 #s(literal 1 binary64) re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re_s re_m im) :precision binary64 (* re_s (* re_m (* 2.0 im))))

C

re\_m = fabs(re);
re\_s = copysign(1.0, re);
assert(re_m < im);
double im_sqr(double re_s, double re_m, double im) {
	return re_s * (re_m * (2.0 * im));
}

Fortran

re\_m = abs(re)
re\_s = copysign(1.0d0, re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re_s, re_m, im)
    real(8), intent (in) :: re_s
    real(8), intent (in) :: re_m
    real(8), intent (in) :: im
    im_sqr = re_s * (re_m * (2.0d0 * im))
end function

Java

re\_m = Math.abs(re);
re\_s = Math.copySign(1.0, re);
assert re_m < im;
public static double im_sqr(double re_s, double re_m, double im) {
	return re_s * (re_m * (2.0 * im));
}

Python

re\_m = math.fabs(re)
re\_s = math.copysign(1.0, re)
[re_m, im] = sort([re_m, im])
def im_sqr(re_s, re_m, im):
	return re_s * (re_m * (2.0 * im))

Julia

re\_m = abs(re)
re\_s = copysign(1.0, re)
re_m, im = sort([re_m, im])
function im_sqr(re_s, re_m, im)
	return Float64(re_s * Float64(re_m * Float64(2.0 * im)))
end

MATLAB

re\_m = abs(re);
re\_s = sign(re) * abs(1.0);
re_m, im = num2cell(sort([re_m, im])){:}
function tmp = im_sqr(re_s, re_m, im)
	tmp = re_s * (re_m * (2.0 * im));
end

Wolfram

re\_m = N[Abs[re], $MachinePrecision]
re\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[re]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: re_m and im should be sorted in increasing order before calling this function.
im$95$sqr[re$95$s_, re$95$m_, im_] := N[(re$95$s * N[(re$95$m * N[(2.0 * im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[re \cdot im + im \cdot re \]
2. Step-by-step derivation

   1. *-commutative N/A

      \[\leadsto re \cdot im + re \cdot \color{blue}{im} \]

   2. distribute-lft-out N/A

      \[\leadsto re \cdot \color{blue}{\left(im + im\right)} \]

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

      \[\leadsto \mathsf{*.f64}\left(re, \color{blue}{\left(im + im\right)}\right) \]

   4. count-2 N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(2 \cdot \color{blue}{im}\right)\right) \]

   5. *-commutative N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(im \cdot \color{blue}{2}\right)\right) \]

   6. *-lowering-*.f64 100.0%

      \[\leadsto \mathsf{*.f64}\left(re, \mathsf{*.f64}\left(im, \color{blue}{2}\right)\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{re \cdot \left(im \cdot 2\right)} \]
4. Add Preprocessing

5. Final simplification 100.0%

   \[\leadsto re \cdot \left(2 \cdot im\right) \]
6. Add Preprocessing

Alternative 3: 0.0% accurate, 2.3× speedup

Math

\[\begin{array}{l} re\_m = \left|re\right| \\ re\_s = \mathsf{copysign}\left(1, re\right) \\ [re_m, im] = \mathsf{sort}([re_m, im])\\ \\ re\_s \cdot \frac{0}{0} \end{array} \]

FPCore

re\_m = (fabs.f64 re)
re\_s = (copysign.f64 #s(literal 1 binary64) re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re_s re_m im) :precision binary64 (* re_s (/ 0.0 0.0)))

C

re\_m = fabs(re);
re\_s = copysign(1.0, re);
assert(re_m < im);
double im_sqr(double re_s, double re_m, double im) {
	return re_s * (0.0 / 0.0);
}

Fortran

re\_m = abs(re)
re\_s = copysign(1.0d0, re)
NOTE: re_m and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re_s, re_m, im)
    real(8), intent (in) :: re_s
    real(8), intent (in) :: re_m
    real(8), intent (in) :: im
    im_sqr = re_s * (0.0d0 / 0.0d0)
end function

Java

re\_m = Math.abs(re);
re\_s = Math.copySign(1.0, re);
assert re_m < im;
public static double im_sqr(double re_s, double re_m, double im) {
	return re_s * (0.0 / 0.0);
}

Python

re\_m = math.fabs(re)
re\_s = math.copysign(1.0, re)
[re_m, im] = sort([re_m, im])
def im_sqr(re_s, re_m, im):
	return re_s * (0.0 / 0.0)

Julia

re\_m = abs(re)
re\_s = copysign(1.0, re)
re_m, im = sort([re_m, im])
function im_sqr(re_s, re_m, im)
	return Float64(re_s * Float64(0.0 / 0.0))
end

MATLAB

re\_m = abs(re);
re\_s = sign(re) * abs(1.0);
re_m, im = num2cell(sort([re_m, im])){:}
function tmp = im_sqr(re_s, re_m, im)
	tmp = re_s * (0.0 / 0.0);
end

Wolfram

re\_m = N[Abs[re], $MachinePrecision]
re\_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[re]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
NOTE: re_m and im should be sorted in increasing order before calling this function.
im$95$sqr[re$95$s_, re$95$m_, im_] := N[(re$95$s * N[(0.0 / 0.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[re \cdot im + im \cdot re \]
2. Step-by-step derivation

   1. *-commutative N/A

      \[\leadsto re \cdot im + re \cdot \color{blue}{im} \]

   2. distribute-lft-out N/A

      \[\leadsto re \cdot \color{blue}{\left(im + im\right)} \]

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

      \[\leadsto \mathsf{*.f64}\left(re, \color{blue}{\left(im + im\right)}\right) \]

   4. count-2 N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(2 \cdot \color{blue}{im}\right)\right) \]

   5. *-commutative N/A

      \[\leadsto \mathsf{*.f64}\left(re, \left(im \cdot \color{blue}{2}\right)\right) \]

   6. *-lowering-*.f64 100.0%

      \[\leadsto \mathsf{*.f64}\left(re, \mathsf{*.f64}\left(im, \color{blue}{2}\right)\right) \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{re \cdot \left(im \cdot 2\right)} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. associate-*r* N/A

      \[\leadsto \left(re \cdot im\right) \cdot \color{blue}{2} \]

   2. *-commutative N/A

      \[\leadsto 2 \cdot \color{blue}{\left(re \cdot im\right)} \]

   3. count-2 N/A

      \[\leadsto re \cdot im + \color{blue}{re \cdot im} \]

   4. *-commutative N/A

      \[\leadsto re \cdot im + im \cdot \color{blue}{re} \]

   5. flip-+ N/A

      \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{\color{blue}{re \cdot im - im \cdot re}} \]

   6. *-commutative N/A

      \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{re \cdot im - re \cdot \color{blue}{im}} \]

   7. +-inverses N/A

      \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{0} \]

   8. +-inverses N/A

      \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \color{blue}{\left(re \cdot im\right) \cdot \left(re \cdot im\right)}} \]

   9. *-commutative N/A

      \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(re \cdot im\right) \cdot \left(im \cdot \color{blue}{re}\right)} \]

   10. *-commutative N/A

       \[\leadsto \frac{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)}{\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(\color{blue}{im} \cdot re\right)} \]

   11. /-lowering-/.f64 N/A

       \[\leadsto \mathsf{/.f64}\left(\left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)\right), \color{blue}{\left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)\right)}\right) \]

   12. *-commutative N/A

       \[\leadsto \mathsf{/.f64}\left(\left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(re \cdot im\right) \cdot \left(im \cdot re\right)\right), \left(\left(re \cdot im\right) \cdot \left(\color{blue}{re} \cdot im\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)\right)\right) \]

   13. *-commutative N/A

       \[\leadsto \mathsf{/.f64}\left(\left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(re \cdot im\right) \cdot \left(re \cdot im\right)\right), \left(\left(re \cdot im\right) \cdot \left(re \cdot \color{blue}{im}\right) - \left(im \cdot re\right) \cdot \left(im \cdot re\right)\right)\right) \]

   14. +-inverses N/A

       \[\leadsto \mathsf{/.f64}\left(0, \left(\color{blue}{\left(re \cdot im\right) \cdot \left(re \cdot im\right)} - \left(im \cdot re\right) \cdot \left(im \cdot re\right)\right)\right) \]

   15. *-commutative N/A

       \[\leadsto \mathsf{/.f64}\left(0, \left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(re \cdot im\right) \cdot \left(\color{blue}{im} \cdot re\right)\right)\right) \]

   16. *-commutative N/A

       \[\leadsto \mathsf{/.f64}\left(0, \left(\left(re \cdot im\right) \cdot \left(re \cdot im\right) - \left(re \cdot im\right) \cdot \left(re \cdot \color{blue}{im}\right)\right)\right) \]

   17. +-inverses 0.0%

       \[\leadsto \mathsf{/.f64}\left(0, 0\right) \]

6. Applied egg-rr 0.0%

   \[\leadsto \color{blue}{\frac{0}{0}} \]
7. Add Preprocessing

Reproduce

herbie shell --seed 2024138 
(FPCore im_sqr (re im)
  :name "math.square on complex, imaginary part"
  :precision binary64
  (+ (* re im) (* im re)))