math.cube on complex, real part

Percentage Accurate: 82.1% → 87.8%

Time: 7.2s

Alternatives: 5

Speedup: 1.0×

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

Specification

Math

\[\begin{array}{l} \\ \left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (-
  (* (- (* x.re x.re) (* x.im x.im)) x.re)
  (* (+ (* x.re x.im) (* x.im x.re)) x.im)))

C

double code(double x_46_re, double x_46_im) {
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = (((x_46re * x_46re) - (x_46im * x_46im)) * x_46re) - (((x_46re * x_46im) + (x_46im * x_46re)) * x_46im)
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
}

Python

def code(x_46_re, x_46_im):
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im)

Julia

function code(x_46_re, x_46_im)
	return Float64(Float64(Float64(Float64(x_46_re * x_46_re) - Float64(x_46_im * x_46_im)) * x_46_re) - Float64(Float64(Float64(x_46_re * x_46_im) + Float64(x_46_im * x_46_re)) * x_46_im))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[(N[(N[(x$46$re * x$46$re), $MachinePrecision] - N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision] * x$46$re), $MachinePrecision] - N[(N[(N[(x$46$re * x$46$im), $MachinePrecision] + N[(x$46$im * x$46$re), $MachinePrecision]), $MachinePrecision] * x$46$im), $MachinePrecision]), $MachinePrecision]

Initial Program: 82.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (-
  (* (- (* x.re x.re) (* x.im x.im)) x.re)
  (* (+ (* x.re x.im) (* x.im x.re)) x.im)))

C

double code(double x_46_re, double x_46_im) {
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = (((x_46re * x_46re) - (x_46im * x_46im)) * x_46re) - (((x_46re * x_46im) + (x_46im * x_46re)) * x_46im)
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
}

Python

def code(x_46_re, x_46_im):
	return (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im)

Julia

function code(x_46_re, x_46_im)
	return Float64(Float64(Float64(Float64(x_46_re * x_46_re) - Float64(x_46_im * x_46_im)) * x_46_re) - Float64(Float64(Float64(x_46_re * x_46_im) + Float64(x_46_im * x_46_re)) * x_46_im))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = (((x_46_re * x_46_re) - (x_46_im * x_46_im)) * x_46_re) - (((x_46_re * x_46_im) + (x_46_im * x_46_re)) * x_46_im);
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[(N[(N[(x$46$re * x$46$re), $MachinePrecision] - N[(x$46$im * x$46$im), $MachinePrecision]), $MachinePrecision] * x$46$re), $MachinePrecision] - N[(N[(N[(x$46$re * x$46$im), $MachinePrecision] + N[(x$46$im * x$46$re), $MachinePrecision]), $MachinePrecision] * x$46$im), $MachinePrecision]), $MachinePrecision]

Alternative 1: 87.8% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right) \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (fma (* x.re x.im) (* x.im -3.0) (pow x.re 3.0)))

C

double code(double x_46_re, double x_46_im) {
	return fma((x_46_re * x_46_im), (x_46_im * -3.0), pow(x_46_re, 3.0));
}

Julia

function code(x_46_re, x_46_im)
	return fma(Float64(x_46_re * x_46_im), Float64(x_46_im * -3.0), (x_46_re ^ 3.0))
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[(x$46$re * x$46$im), $MachinePrecision] * N[(x$46$im * -3.0), $MachinePrecision] + N[Power[x$46$re, 3.0], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \]

3. Simplified 83.0%

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

   1. associate-*r* 83.0%

      \[\leadsto {x.re}^{3} + x.re \cdot \color{blue}{\left(\left(x.im \cdot x.im\right) \cdot -3\right)} \]

   2. associate-*l* 83.0%

      \[\leadsto {x.re}^{3} + \color{blue}{\left(x.re \cdot \left(x.im \cdot x.im\right)\right) \cdot -3} \]

   3. +-commutative 83.0%

      \[\leadsto \color{blue}{\left(x.re \cdot \left(x.im \cdot x.im\right)\right) \cdot -3 + {x.re}^{3}} \]

   4. associate-*r* 87.4%

      \[\leadsto \color{blue}{\left(\left(x.re \cdot x.im\right) \cdot x.im\right)} \cdot -3 + {x.re}^{3} \]

   5. associate-*r* 87.4%

      \[\leadsto \color{blue}{\left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right)} + {x.re}^{3} \]

   6. fma-define 88.9%

      \[\leadsto \color{blue}{\mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right)} \]

6. Applied egg-rr 88.9%

   \[\leadsto \color{blue}{\mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right)} \]

7. Final simplification 88.9%

   \[\leadsto \mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right) \]
8. Add Preprocessing

Alternative 2: 85.8% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ {x.re}^{3} + \left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right) \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (+ (pow x.re 3.0) (* (* x.re x.im) (* x.im -3.0))))

C

double code(double x_46_re, double x_46_im) {
	return pow(x_46_re, 3.0) + ((x_46_re * x_46_im) * (x_46_im * -3.0));
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = (x_46re ** 3.0d0) + ((x_46re * x_46im) * (x_46im * (-3.0d0)))
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return Math.pow(x_46_re, 3.0) + ((x_46_re * x_46_im) * (x_46_im * -3.0));
}

Python

def code(x_46_re, x_46_im):
	return math.pow(x_46_re, 3.0) + ((x_46_re * x_46_im) * (x_46_im * -3.0))

Julia

function code(x_46_re, x_46_im)
	return Float64((x_46_re ^ 3.0) + Float64(Float64(x_46_re * x_46_im) * Float64(x_46_im * -3.0)))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = (x_46_re ^ 3.0) + ((x_46_re * x_46_im) * (x_46_im * -3.0));
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[Power[x$46$re, 3.0], $MachinePrecision] + N[(N[(x$46$re * x$46$im), $MachinePrecision] * N[(x$46$im * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \]

3. Simplified 83.0%

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

   1. associate-*r* 83.0%

      \[\leadsto {x.re}^{3} + x.re \cdot \color{blue}{\left(\left(x.im \cdot x.im\right) \cdot -3\right)} \]

   2. associate-*l* 83.0%

      \[\leadsto {x.re}^{3} + \color{blue}{\left(x.re \cdot \left(x.im \cdot x.im\right)\right) \cdot -3} \]

   3. +-commutative 83.0%

      \[\leadsto \color{blue}{\left(x.re \cdot \left(x.im \cdot x.im\right)\right) \cdot -3 + {x.re}^{3}} \]

   4. associate-*r* 87.4%

      \[\leadsto \color{blue}{\left(\left(x.re \cdot x.im\right) \cdot x.im\right)} \cdot -3 + {x.re}^{3} \]

   5. associate-*r* 87.4%

      \[\leadsto \color{blue}{\left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right)} + {x.re}^{3} \]

   6. fma-define 88.9%

      \[\leadsto \color{blue}{\mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right)} \]

6. Applied egg-rr 88.9%

   \[\leadsto \color{blue}{\mathsf{fma}\left(x.re \cdot x.im, x.im \cdot -3, {x.re}^{3}\right)} \]
7. Step-by-step derivation

   1. fma-undefine 87.4%

      \[\leadsto \color{blue}{\left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right) + {x.re}^{3}} \]

   2. +-commutative 87.4%

      \[\leadsto \color{blue}{{x.re}^{3} + \left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right)} \]

8. Applied egg-rr 87.4%

   \[\leadsto \color{blue}{{x.re}^{3} + \left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right)} \]

9. Final simplification 87.4%

   \[\leadsto {x.re}^{3} + \left(x.re \cdot x.im\right) \cdot \left(x.im \cdot -3\right) \]
10. Add Preprocessing

Alternative 3: 85.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x.re \cdot \left(\left(x.re - x.im\right) \cdot \left(x.re + x.im\right)\right) - x.im \cdot \left(x.re \cdot x.im + x.re \cdot x.im\right) \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (-
  (* x.re (* (- x.re x.im) (+ x.re x.im)))
  (* x.im (+ (* x.re x.im) (* x.re x.im)))))

C

double code(double x_46_re, double x_46_im) {
	return (x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im))) - (x_46_im * ((x_46_re * x_46_im) + (x_46_re * x_46_im)));
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = (x_46re * ((x_46re - x_46im) * (x_46re + x_46im))) - (x_46im * ((x_46re * x_46im) + (x_46re * x_46im)))
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return (x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im))) - (x_46_im * ((x_46_re * x_46_im) + (x_46_re * x_46_im)));
}

Python

def code(x_46_re, x_46_im):
	return (x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im))) - (x_46_im * ((x_46_re * x_46_im) + (x_46_re * x_46_im)))

Julia

function code(x_46_re, x_46_im)
	return Float64(Float64(x_46_re * Float64(Float64(x_46_re - x_46_im) * Float64(x_46_re + x_46_im))) - Float64(x_46_im * Float64(Float64(x_46_re * x_46_im) + Float64(x_46_re * x_46_im))))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = (x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im))) - (x_46_im * ((x_46_re * x_46_im) + (x_46_re * x_46_im)));
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[(x$46$re * N[(N[(x$46$re - x$46$im), $MachinePrecision] * N[(x$46$re + x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x$46$im * N[(N[(x$46$re * x$46$im), $MachinePrecision] + N[(x$46$re * x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \]
2. Add Preprocessing
3. Step-by-step derivation

   1. difference-of-squares 80.1%

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

   2. *-commutative 80.1%

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

4. Applied egg-rr 86.1%

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

5. Final simplification 86.1%

   \[\leadsto x.re \cdot \left(\left(x.re - x.im\right) \cdot \left(x.re + x.im\right)\right) - x.im \cdot \left(x.re \cdot x.im + x.re \cdot x.im\right) \]
6. Add Preprocessing

Alternative 4: 62.8% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x.re \cdot \left(x.re - x.im\right)\\ x.re \cdot t\_0 + x.im \cdot t\_0 \end{array} \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (let* ((t_0 (* x.re (- x.re x.im)))) (+ (* x.re t_0) (* x.im t_0))))

C

double code(double x_46_re, double x_46_im) {
	double t_0 = x_46_re * (x_46_re - x_46_im);
	return (x_46_re * t_0) + (x_46_im * t_0);
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    real(8) :: t_0
    t_0 = x_46re * (x_46re - x_46im)
    code = (x_46re * t_0) + (x_46im * t_0)
end function

Java

public static double code(double x_46_re, double x_46_im) {
	double t_0 = x_46_re * (x_46_re - x_46_im);
	return (x_46_re * t_0) + (x_46_im * t_0);
}

Python

def code(x_46_re, x_46_im):
	t_0 = x_46_re * (x_46_re - x_46_im)
	return (x_46_re * t_0) + (x_46_im * t_0)

Julia

function code(x_46_re, x_46_im)
	t_0 = Float64(x_46_re * Float64(x_46_re - x_46_im))
	return Float64(Float64(x_46_re * t_0) + Float64(x_46_im * t_0))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	t_0 = x_46_re * (x_46_re - x_46_im);
	tmp = (x_46_re * t_0) + (x_46_im * t_0);
end

Wolfram

code[x$46$re_, x$46$im_] := Block[{t$95$0 = N[(x$46$re * N[(x$46$re - x$46$im), $MachinePrecision]), $MachinePrecision]}, N[(N[(x$46$re * t$95$0), $MachinePrecision] + N[(x$46$im * t$95$0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 83.7%

   \[\left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \]
2. Add Preprocessing
3. Step-by-step derivation

   1. *-commutative 83.7%

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

   2. *-commutative 83.7%

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

   3. flip-+ 0.0%

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

   4. +-inverses 0.0%

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

   5. metadata-eval 0.0%

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

   6. +-inverses 0.0%

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

   7. metadata-eval 0.0%

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

   8. associate-*r/ 0.0%

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

   9. metadata-eval 0.0%

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

   10. metadata-eval 0.0%

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

4. Applied egg-rr 0.0%

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

6. Simplified 74.7%

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

   1. difference-of-squares 80.1%

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

   2. *-commutative 80.1%

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

8. Applied egg-rr 80.1%

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

   1. *-commutative 80.1%

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

   2. distribute-rgt-in 73.9%

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

   3. distribute-rgt-in 70.0%

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

10. Applied egg-rr 70.0%

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

11. Taylor expanded in x.im around 0 61.1%

    \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + \color{blue}{x.im \cdot \left(-1 \cdot \left(x.im \cdot x.re\right) + {x.re}^{2}\right)}\right) - 0 \]
12. Step-by-step derivation

    1. neg-mul-1 61.1%

       \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + x.im \cdot \left(\color{blue}{\left(-x.im \cdot x.re\right)} + {x.re}^{2}\right)\right) - 0 \]

    2. neg-sub0 61.1%

       \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + x.im \cdot \left(\color{blue}{\left(0 - x.im \cdot x.re\right)} + {x.re}^{2}\right)\right) - 0 \]

    3. +-commutative 61.1%

       \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + x.im \cdot \color{blue}{\left({x.re}^{2} + \left(0 - x.im \cdot x.re\right)\right)}\right) - 0 \]

    4. neg-sub0 61.1%

       \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + x.im \cdot \left({x.re}^{2} + \color{blue}{\left(-x.im \cdot x.re\right)}\right)\right) - 0 \]

    5. unsub-neg 61.1%

       \[\leadsto \left(\left(x.re \cdot \left(x.re - x.im\right)\right) \cdot x.re + x.im \cdot \color{blue}{\left({x.re}^{2} - x.im \cdot x.re\right)}\right) - 0 \]

    6. unpow2 61.1%

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

    7. distribute-rgt-out-- 66.6%

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

13. Simplified 66.6%

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

14. Final simplification 66.6%

    \[\leadsto x.re \cdot \left(x.re \cdot \left(x.re - x.im\right)\right) + x.im \cdot \left(x.re \cdot \left(x.re - x.im\right)\right) \]
15. Add Preprocessing

Alternative 5: 78.1% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ x.re \cdot \left(\left(x.re - x.im\right) \cdot \left(x.re + x.im\right)\right) \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (* x.re (* (- x.re x.im) (+ x.re x.im))))

C

double code(double x_46_re, double x_46_im) {
	return x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im));
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = x_46re * ((x_46re - x_46im) * (x_46re + x_46im))
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im));
}

Python

def code(x_46_re, x_46_im):
	return x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im))

Julia

function code(x_46_re, x_46_im)
	return Float64(x_46_re * Float64(Float64(x_46_re - x_46_im) * Float64(x_46_re + x_46_im)))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = x_46_re * ((x_46_re - x_46_im) * (x_46_re + x_46_im));
end

Wolfram

code[x$46$re_, x$46$im_] := N[(x$46$re * N[(N[(x$46$re - x$46$im), $MachinePrecision] * N[(x$46$re + x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\left(x.re \cdot x.re - x.im \cdot x.im\right) \cdot x.re - \left(x.re \cdot x.im + x.im \cdot x.re\right) \cdot x.im \]
2. Add Preprocessing
3. Step-by-step derivation

   1. *-commutative 83.7%

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

   2. *-commutative 83.7%

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

   3. flip-+ 0.0%

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

   4. +-inverses 0.0%

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

   5. metadata-eval 0.0%

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

   6. +-inverses 0.0%

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

   7. metadata-eval 0.0%

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

   8. associate-*r/ 0.0%

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

   9. metadata-eval 0.0%

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

   10. metadata-eval 0.0%

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

4. Applied egg-rr 0.0%

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

6. Simplified 74.7%

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

   1. difference-of-squares 80.1%

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

   2. *-commutative 80.1%

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

8. Applied egg-rr 80.1%

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

9. Final simplification 80.1%

   \[\leadsto x.re \cdot \left(\left(x.re - x.im\right) \cdot \left(x.re + x.im\right)\right) \]
10. Add Preprocessing

Developer target: 87.3% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \left(x.re \cdot x.re\right) \cdot \left(x.re - x.im\right) + \left(x.re \cdot x.im\right) \cdot \left(x.re - 3 \cdot x.im\right) \end{array} \]

FPCore

(FPCore (x.re x.im)
 :precision binary64
 (+ (* (* x.re x.re) (- x.re x.im)) (* (* x.re x.im) (- x.re (* 3.0 x.im)))))

C

double code(double x_46_re, double x_46_im) {
	return ((x_46_re * x_46_re) * (x_46_re - x_46_im)) + ((x_46_re * x_46_im) * (x_46_re - (3.0 * x_46_im)));
}

Fortran

real(8) function code(x_46re, x_46im)
    real(8), intent (in) :: x_46re
    real(8), intent (in) :: x_46im
    code = ((x_46re * x_46re) * (x_46re - x_46im)) + ((x_46re * x_46im) * (x_46re - (3.0d0 * x_46im)))
end function

Java

public static double code(double x_46_re, double x_46_im) {
	return ((x_46_re * x_46_re) * (x_46_re - x_46_im)) + ((x_46_re * x_46_im) * (x_46_re - (3.0 * x_46_im)));
}

Python

def code(x_46_re, x_46_im):
	return ((x_46_re * x_46_re) * (x_46_re - x_46_im)) + ((x_46_re * x_46_im) * (x_46_re - (3.0 * x_46_im)))

Julia

function code(x_46_re, x_46_im)
	return Float64(Float64(Float64(x_46_re * x_46_re) * Float64(x_46_re - x_46_im)) + Float64(Float64(x_46_re * x_46_im) * Float64(x_46_re - Float64(3.0 * x_46_im))))
end

MATLAB

function tmp = code(x_46_re, x_46_im)
	tmp = ((x_46_re * x_46_re) * (x_46_re - x_46_im)) + ((x_46_re * x_46_im) * (x_46_re - (3.0 * x_46_im)));
end

Wolfram

code[x$46$re_, x$46$im_] := N[(N[(N[(x$46$re * x$46$re), $MachinePrecision] * N[(x$46$re - x$46$im), $MachinePrecision]), $MachinePrecision] + N[(N[(x$46$re * x$46$im), $MachinePrecision] * N[(x$46$re - N[(3.0 * x$46$im), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024066 
(FPCore (x.re x.im)
  :name "math.cube on complex, real part"
  :precision binary64

  :alt
  (+ (* (* x.re x.re) (- x.re x.im)) (* (* x.re x.im) (- x.re (* 3.0 x.im))))

  (- (* (- (* x.re x.re) (* x.im x.im)) x.re) (* (+ (* x.re x.im) (* x.im x.re)) x.im)))