math.square on complex, imaginary part

Percentage Accurate: 100.0% → 100.0%

Time: 1.4s

Alternatives: 3

Speedup: 1.4×

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, im] = \mathsf{sort}([re, im])\\ \\ \left(re \cdot 2\right) \cdot im \end{array} \]

FPCore

NOTE: re and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re im) :precision binary64 (* (* re 2.0) im))

C

assert(re < im);
double im_sqr(double re, double im) {
	return (re * 2.0) * im;
}

Fortran

NOTE: re and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    im_sqr = (re * 2.0d0) * im
end function

Java

assert re < im;
public static double im_sqr(double re, double im) {
	return (re * 2.0) * im;
}

Python

[re, im] = sort([re, im])
def im_sqr(re, im):
	return (re * 2.0) * im

Julia

re, im = sort([re, im])
function im_sqr(re, im)
	return Float64(Float64(re * 2.0) * im)
end

MATLAB

re, im = num2cell(sort([re, im])){:}
function tmp = im_sqr(re, im)
	tmp = (re * 2.0) * im;
end

Wolfram

NOTE: re and im should be sorted in increasing order before calling this function.
im$95$sqr[re_, im_] := N[(N[(re * 2.0), $MachinePrecision] * im), $MachinePrecision]

Derivation

1. Initial program 100.0%

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

   1. *-commutative 100.0%

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

   2. distribute-lft-in 99.6%

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

   3. count-2 99.6%

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

   4. associate-*r* 99.6%

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

3. Applied egg-rr 99.6%

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

4. Final simplification 99.6%

   \[\leadsto \left(re \cdot 2\right) \cdot im \]

Alternative 2: 100.0% accurate, 1.4× speedup

Math

\[\begin{array}{l} [re, im] = \mathsf{sort}([re, im])\\ \\ re \cdot \left(im + im\right) \end{array} \]

FPCore

NOTE: re and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re im) :precision binary64 (* re (+ im im)))

C

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

Fortran

NOTE: re and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    im_sqr = re * (im + im)
end function

Java

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

Python

[re, im] = sort([re, im])
def im_sqr(re, im):
	return re * (im + im)

Julia

re, im = sort([re, im])
function im_sqr(re, im)
	return Float64(re * Float64(im + im))
end

MATLAB

re, im = num2cell(sort([re, im])){:}
function tmp = im_sqr(re, im)
	tmp = re * (im + im);
end

Wolfram

NOTE: re and im should be sorted in increasing order before calling this function.
im$95$sqr[re_, im_] := N[(re * N[(im + im), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 100.0%

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

   1. *-commutative 100.0%

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

   2. distribute-rgt-out 99.6%

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

3. Simplified 99.6%

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

4. Final simplification 99.6%

   \[\leadsto re \cdot \left(im + im\right) \]

Alternative 3: 3.4% accurate, 7.0× speedup

Math

\[\begin{array}{l} [re, im] = \mathsf{sort}([re, im])\\ \\ -2 \end{array} \]

FPCore

NOTE: re and im should be sorted in increasing order before calling this function.
(FPCore im_sqr (re im) :precision binary64 -2.0)

C

assert(re < im);
double im_sqr(double re, double im) {
	return -2.0;
}

Fortran

NOTE: re and im should be sorted in increasing order before calling this function.
real(8) function im_sqr(re, im)
    real(8), intent (in) :: re
    real(8), intent (in) :: im
    im_sqr = -2.0d0
end function

Java

assert re < im;
public static double im_sqr(double re, double im) {
	return -2.0;
}

Python

[re, im] = sort([re, im])
def im_sqr(re, im):
	return -2.0

Julia

re, im = sort([re, im])
function im_sqr(re, im)
	return -2.0
end

MATLAB

re, im = num2cell(sort([re, im])){:}
function tmp = im_sqr(re, im)
	tmp = -2.0;
end

Wolfram

NOTE: re and im should be sorted in increasing order before calling this function.
im$95$sqr[re_, im_] := -2.0

Derivation

1. Initial program 100.0%

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

   1. *-commutative 100.0%

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

   2. distribute-rgt-out 99.6%

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

3. Simplified 99.6%

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

   1. expm1-log1p-u 70.8%

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

   2. expm1-udef 35.0%

      \[\leadsto \color{blue}{e^{\mathsf{log1p}\left(re \cdot \left(im + im\right)\right)} - 1} \]

   3. log1p-udef 35.0%

      \[\leadsto e^{\color{blue}{\log \left(1 + re \cdot \left(im + im\right)\right)}} - 1 \]

   4. add-exp-log 63.8%

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

   5. distribute-rgt-in 64.2%

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

   6. flip-+ 0.0%

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

   7. +-inverses 0.0%

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

   8. +-inverses 0.0%

      \[\leadsto \left(1 + \frac{0}{\color{blue}{0}}\right) - 1 \]

5. Applied egg-rr 0.0%

   \[\leadsto \color{blue}{\left(1 + \frac{0}{0}\right) - 1} \]

7. Simplified 3.7%

   \[\leadsto \color{blue}{-2} \]

8. Final simplification 3.7%

   \[\leadsto -2 \]

Reproduce

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