Rump's expression from Stadtherr's award speech

Percentage Accurate: 9.2% → 20.2%

Time: 6.7s

Alternatives: 2

Speedup: 44.0×

Specification

\[x = 77617 \land y = 33096\]

Math

\[\begin{array}{l} \\ -0.8273960599468214 \end{array} \]

FPCore

(FPCore (x y) :precision binary64 -0.8273960599468214)

C

double code(double x, double y) {
	return -0.8273960599468214;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = -0.8273960599468214d0
end function

Java

public static double code(double x, double y) {
	return -0.8273960599468214;
}

Python

def code(x, y):
	return -0.8273960599468214

Julia

function code(x, y)
	return -0.8273960599468214
end

MATLAB

function tmp = code(x, y)
	tmp = -0.8273960599468214;
end

Wolfram

code[x_, y_] := -0.8273960599468214

Initial Program: 9.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(333.75 \cdot {y}^{6} + \left(x \cdot x\right) \cdot \left(\left(\left(\left(\left(\left(11 \cdot x\right) \cdot x\right) \cdot y\right) \cdot y - {y}^{6}\right) - 121 \cdot {y}^{4}\right) - 2\right)\right) + 5.5 \cdot {y}^{8}\right) + \frac{x}{2 \cdot y} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (+
  (+
   (+
    (* 333.75 (pow y 6.0))
    (*
     (* x x)
     (-
      (- (- (* (* (* (* 11.0 x) x) y) y) (pow y 6.0)) (* 121.0 (pow y 4.0)))
      2.0)))
   (* 5.5 (pow y 8.0)))
  (/ x (* 2.0 y))))

C

double code(double x, double y) {
	return (((333.75 * pow(y, 6.0)) + ((x * x) * (((((((11.0 * x) * x) * y) * y) - pow(y, 6.0)) - (121.0 * pow(y, 4.0))) - 2.0))) + (5.5 * pow(y, 8.0))) + (x / (2.0 * y));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (((333.75d0 * (y ** 6.0d0)) + ((x * x) * (((((((11.0d0 * x) * x) * y) * y) - (y ** 6.0d0)) - (121.0d0 * (y ** 4.0d0))) - 2.0d0))) + (5.5d0 * (y ** 8.0d0))) + (x / (2.0d0 * y))
end function

Java

public static double code(double x, double y) {
	return (((333.75 * Math.pow(y, 6.0)) + ((x * x) * (((((((11.0 * x) * x) * y) * y) - Math.pow(y, 6.0)) - (121.0 * Math.pow(y, 4.0))) - 2.0))) + (5.5 * Math.pow(y, 8.0))) + (x / (2.0 * y));
}

Python

def code(x, y):
	return (((333.75 * math.pow(y, 6.0)) + ((x * x) * (((((((11.0 * x) * x) * y) * y) - math.pow(y, 6.0)) - (121.0 * math.pow(y, 4.0))) - 2.0))) + (5.5 * math.pow(y, 8.0))) + (x / (2.0 * y))

Julia

function code(x, y)
	return Float64(Float64(Float64(Float64(333.75 * (y ^ 6.0)) + Float64(Float64(x * x) * Float64(Float64(Float64(Float64(Float64(Float64(Float64(11.0 * x) * x) * y) * y) - (y ^ 6.0)) - Float64(121.0 * (y ^ 4.0))) - 2.0))) + Float64(5.5 * (y ^ 8.0))) + Float64(x / Float64(2.0 * y)))
end

MATLAB

function tmp = code(x, y)
	tmp = (((333.75 * (y ^ 6.0)) + ((x * x) * (((((((11.0 * x) * x) * y) * y) - (y ^ 6.0)) - (121.0 * (y ^ 4.0))) - 2.0))) + (5.5 * (y ^ 8.0))) + (x / (2.0 * y));
end

Wolfram

code[x_, y_] := N[(N[(N[(N[(333.75 * N[Power[y, 6.0], $MachinePrecision]), $MachinePrecision] + N[(N[(x * x), $MachinePrecision] * N[(N[(N[(N[(N[(N[(N[(11.0 * x), $MachinePrecision] * x), $MachinePrecision] * y), $MachinePrecision] * y), $MachinePrecision] - N[Power[y, 6.0], $MachinePrecision]), $MachinePrecision] - N[(121.0 * N[Power[y, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(5.5 * N[Power[y, 8.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(x / N[(2.0 * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 20.2% accurate, 28.5× speedup

Math

\[\begin{array}{l} \\ \frac{x \cdot -0.5}{y} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (/ (* x -0.5) y))

C

double code(double x, double y) {
	return (x * -0.5) / y;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (x * (-0.5d0)) / y
end function

Java

public static double code(double x, double y) {
	return (x * -0.5) / y;
}

Python

def code(x, y):
	return (x * -0.5) / y

Julia

function code(x, y)
	return Float64(Float64(x * -0.5) / y)
end

MATLAB

function tmp = code(x, y)
	tmp = (x * -0.5) / y;
end

Wolfram

code[x_, y_] := N[(N[(x * -0.5), $MachinePrecision] / y), $MachinePrecision]

Derivation

1. Initial program 9.2%

   \[\left(\left(333.75 \cdot {y}^{6} + \left(x \cdot x\right) \cdot \left(\left(\left(\left(\left(\left(11 \cdot x\right) \cdot x\right) \cdot y\right) \cdot y - {y}^{6}\right) - 121 \cdot {y}^{4}\right) - 2\right)\right) + 5.5 \cdot {y}^{8}\right) + \frac{x}{2 \cdot y} \]
2. Add Preprocessing

3. Taylor expanded in y around 0

   \[\leadsto \color{blue}{-2 \cdot {x}^{2}} + \frac{x}{2 \cdot y} \]
4. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \color{blue}{-2 \cdot {x}^{2}} + \frac{x}{2 \cdot y} \]

   2. unpow2 N/A

      \[\leadsto -2 \cdot \color{blue}{\left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

   3. lower-*.f64 10.8

      \[\leadsto -2 \cdot \color{blue}{\left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

5. Applied rewrites 10.8%

   \[\leadsto \color{blue}{-2 \cdot \left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

7. Applied rewrites 10.8%

   \[\leadsto \color{blue}{\frac{\mathsf{fma}\left(\left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right) \cdot \left(x \cdot \left(x \cdot x\right)\right), \left(\left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right) \cdot \left(x \cdot \left(x \cdot x\right)\right)\right) \cdot -512, \frac{\left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right) \cdot \left(x \cdot \left(x \cdot x\right)\right)}{-512 \cdot \left(\left(y \cdot \left(y \cdot y\right)\right) \cdot \left(\left(y \cdot \left(y \cdot y\right)\right) \cdot \left(y \cdot \left(y \cdot y\right)\right)\right)\right)}\right) \cdot \frac{1}{\mathsf{fma}\left(x \cdot x, \left(x \cdot x\right) \cdot 4 - \frac{x}{-y}, \frac{x \cdot x}{\left(y \cdot y\right) \cdot 4}\right)}}{\mathsf{fma}\left(\frac{x \cdot \left(x \cdot x\right)}{-8 \cdot \left(y \cdot \left(y \cdot y\right)\right)}, \frac{x \cdot \left(x \cdot x\right)}{-8 \cdot \left(y \cdot \left(y \cdot y\right)\right)} - -8 \cdot \left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right), \left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right) \cdot \left(\left(\left(x \cdot x\right) \cdot \left(x \cdot \left(x \cdot \left(x \cdot x\right)\right)\right)\right) \cdot 64\right)\right)}} \]

8. Taylor expanded in x around 0

   \[\leadsto \color{blue}{\frac{-1}{2} \cdot \frac{x}{y}} \]
9. Step-by-step derivation

   1. associate-*r/ N/A

      \[\leadsto \color{blue}{\frac{\frac{-1}{2} \cdot x}{y}} \]

   2. lower-/.f64 N/A

      \[\leadsto \color{blue}{\frac{\frac{-1}{2} \cdot x}{y}} \]

   3. *-commutative N/A

      \[\leadsto \frac{\color{blue}{x \cdot \frac{-1}{2}}}{y} \]

   4. lower-*.f64 20.2

      \[\leadsto \frac{\color{blue}{x \cdot -0.5}}{y} \]

10. Applied rewrites 20.2%

    \[\leadsto \color{blue}{\frac{x \cdot -0.5}{y}} \]
11. Add Preprocessing

Alternative 2: 10.8% accurate, 44.0× speedup

Math

\[\begin{array}{l} \\ x \cdot \left(x \cdot -2\right) \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* x (* x -2.0)))

C

double code(double x, double y) {
	return x * (x * -2.0);
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = x * (x * (-2.0d0))
end function

Java

public static double code(double x, double y) {
	return x * (x * -2.0);
}

Python

def code(x, y):
	return x * (x * -2.0)

Julia

function code(x, y)
	return Float64(x * Float64(x * -2.0))
end

MATLAB

function tmp = code(x, y)
	tmp = x * (x * -2.0);
end

Wolfram

code[x_, y_] := N[(x * N[(x * -2.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 9.2%

   \[\left(\left(333.75 \cdot {y}^{6} + \left(x \cdot x\right) \cdot \left(\left(\left(\left(\left(\left(11 \cdot x\right) \cdot x\right) \cdot y\right) \cdot y - {y}^{6}\right) - 121 \cdot {y}^{4}\right) - 2\right)\right) + 5.5 \cdot {y}^{8}\right) + \frac{x}{2 \cdot y} \]
2. Add Preprocessing

3. Taylor expanded in y around 0

   \[\leadsto \color{blue}{-2 \cdot {x}^{2}} + \frac{x}{2 \cdot y} \]
4. Step-by-step derivation

   1. lower-*.f64 N/A

      \[\leadsto \color{blue}{-2 \cdot {x}^{2}} + \frac{x}{2 \cdot y} \]

   2. unpow2 N/A

      \[\leadsto -2 \cdot \color{blue}{\left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

   3. lower-*.f64 10.8

      \[\leadsto -2 \cdot \color{blue}{\left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

5. Applied rewrites 10.8%

   \[\leadsto \color{blue}{-2 \cdot \left(x \cdot x\right)} + \frac{x}{2 \cdot y} \]

6. Taylor expanded in x around inf

   \[\leadsto \color{blue}{-2 \cdot {x}^{2}} \]
7. Step-by-step derivation

   1. unpow2 N/A

      \[\leadsto -2 \cdot \color{blue}{\left(x \cdot x\right)} \]

   2. associate-*r* N/A

      \[\leadsto \color{blue}{\left(-2 \cdot x\right) \cdot x} \]

   3. *-commutative N/A

      \[\leadsto \color{blue}{x \cdot \left(-2 \cdot x\right)} \]

   4. lower-*.f64 N/A

      \[\leadsto \color{blue}{x \cdot \left(-2 \cdot x\right)} \]

   5. *-commutative N/A

      \[\leadsto x \cdot \color{blue}{\left(x \cdot -2\right)} \]

   6. lower-*.f64 10.8

      \[\leadsto x \cdot \color{blue}{\left(x \cdot -2\right)} \]

8. Applied rewrites 10.8%

   \[\leadsto \color{blue}{x \cdot \left(x \cdot -2\right)} \]
9. Add Preprocessing

Reproduce

herbie shell --seed 2024221 
(FPCore (x y)
  :name "Rump's expression from Stadtherr's award speech"
  :precision binary64
  :pre (and (== x 77617.0) (== y 33096.0))
  (+ (+ (+ (* 333.75 (pow y 6.0)) (* (* x x) (- (- (- (* (* (* (* 11.0 x) x) y) y) (pow y 6.0)) (* 121.0 (pow y 4.0))) 2.0))) (* 5.5 (pow y 8.0))) (/ x (* 2.0 y))))