From Rump in a 1983 paper, rewritten

Percentage Accurate: 3.1% → 100.0%

Time: 6.9s

Alternatives: 4

Speedup: 1.1×

Specification

\[x = 10864 \land y = 18817\]

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (- (* 9.0 (pow x 4.0)) (* (* y y) (- (* y y) 2.0))))

C

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

Fortran

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

Java

public static double code(double x, double y) {
	return (9.0 * Math.pow(x, 4.0)) - ((y * y) * ((y * y) - 2.0));
}

Python

def code(x, y):
	return (9.0 * math.pow(x, 4.0)) - ((y * y) * ((y * y) - 2.0))

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 3.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y)
 :precision binary64
 (- (* 9.0 (pow x 4.0)) (* (* y y) (- (* y y) 2.0))))

C

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

Fortran

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

Java

public static double code(double x, double y) {
	return (9.0 * Math.pow(x, 4.0)) - ((y * y) * ((y * y) - 2.0));
}

Python

def code(x, y):
	return (9.0 * math.pow(x, 4.0)) - ((y * y) * ((y * y) - 2.0))

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(-y, y \cdot \mathsf{fma}\left(y, y, -2\right), 9 \cdot {x}^{4}\right) \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (fma (- y) (* y (fma y y -2.0)) (* 9.0 (pow x 4.0))))

C

double code(double x, double y) {
	return fma(-y, (y * fma(y, y, -2.0)), (9.0 * pow(x, 4.0)));
}

Julia

function code(x, y)
	return fma(Float64(-y), Float64(y * fma(y, y, -2.0)), Float64(9.0 * (x ^ 4.0)))
end

Wolfram

code[x_, y_] := N[((-y) * N[(y * N[(y * y + -2.0), $MachinePrecision]), $MachinePrecision] + N[(9.0 * N[Power[x, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 3.1%

   \[9 \cdot {x}^{4} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]
2. Add Preprocessing
3. Step-by-step derivation

   1. sub-neg 3.1%

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

   2. +-commutative 3.1%

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

   3. associate-*l* 3.1%

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

   4. distribute-lft-neg-in 3.1%

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

   5. fma-define 100.0%

      \[\leadsto \color{blue}{\mathsf{fma}\left(-y, y \cdot \left(y \cdot y - 2\right), 9 \cdot {x}^{4}\right)} \]

   6. fmm-def 100.0%

      \[\leadsto \mathsf{fma}\left(-y, y \cdot \color{blue}{\mathsf{fma}\left(y, y, -2\right)}, 9 \cdot {x}^{4}\right) \]

   7. metadata-eval 100.0%

      \[\leadsto \mathsf{fma}\left(-y, y \cdot \mathsf{fma}\left(y, y, \color{blue}{-2}\right), 9 \cdot {x}^{4}\right) \]

4. Applied egg-rr 100.0%

   \[\leadsto \color{blue}{\mathsf{fma}\left(-y, y \cdot \mathsf{fma}\left(y, y, -2\right), 9 \cdot {x}^{4}\right)} \]
5. Add Preprocessing

Alternative 2: 14.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ 9 \cdot e^{4 \cdot \log x} + \left(y \cdot y\right) \cdot \left(2 - y \cdot y\right) \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (+ (* 9.0 (exp (* 4.0 (log x)))) (* (* y y) (- 2.0 (* y y)))))

C

double code(double x, double y) {
	return (9.0 * exp((4.0 * log(x)))) + ((y * y) * (2.0 - (y * y)));
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    code = (9.0d0 * exp((4.0d0 * log(x)))) + ((y * y) * (2.0d0 - (y * y)))
end function

Java

public static double code(double x, double y) {
	return (9.0 * Math.exp((4.0 * Math.log(x)))) + ((y * y) * (2.0 - (y * y)));
}

Python

def code(x, y):
	return (9.0 * math.exp((4.0 * math.log(x)))) + ((y * y) * (2.0 - (y * y)))

Julia

function code(x, y)
	return Float64(Float64(9.0 * exp(Float64(4.0 * log(x)))) + Float64(Float64(y * y) * Float64(2.0 - Float64(y * y))))
end

MATLAB

function tmp = code(x, y)
	tmp = (9.0 * exp((4.0 * log(x)))) + ((y * y) * (2.0 - (y * y)));
end

Wolfram

code[x_, y_] := N[(N[(9.0 * N[Exp[N[(4.0 * N[Log[x], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(N[(y * y), $MachinePrecision] * N[(2.0 - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 3.1%

   \[9 \cdot {x}^{4} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]
2. Add Preprocessing
3. Step-by-step derivation

   1. add-exp-log 14.1%

      \[\leadsto 9 \cdot \color{blue}{e^{\log \left({x}^{4}\right)}} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]

   2. log-pow 14.1%

      \[\leadsto 9 \cdot e^{\color{blue}{4 \cdot \log x}} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]

4. Applied egg-rr 14.1%

   \[\leadsto 9 \cdot \color{blue}{e^{4 \cdot \log x}} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]

5. Final simplification 14.1%

   \[\leadsto 9 \cdot e^{4 \cdot \log x} + \left(y \cdot y\right) \cdot \left(2 - y \cdot y\right) \]
6. Add Preprocessing

Alternative 3: 9.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ 9 \cdot {x}^{4} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (* 9.0 (pow x 4.0)))

C

double code(double x, double y) {
	return 9.0 * pow(x, 4.0);
}

Fortran

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

Java

public static double code(double x, double y) {
	return 9.0 * Math.pow(x, 4.0);
}

Python

def code(x, y):
	return 9.0 * math.pow(x, 4.0)

Julia

function code(x, y)
	return Float64(9.0 * (x ^ 4.0))
end

MATLAB

function tmp = code(x, y)
	tmp = 9.0 * (x ^ 4.0);
end

Wolfram

code[x_, y_] := N[(9.0 * N[Power[x, 4.0], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 3.1%

   \[9 \cdot {x}^{4} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]
2. Add Preprocessing

3. Taylor expanded in x around inf 9.6%

   \[\leadsto \color{blue}{9 \cdot {x}^{4}} \]
4. Add Preprocessing

Alternative 4: 9.6% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ {y}^{4} \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (pow y 4.0))

C

double code(double x, double y) {
	return pow(y, 4.0);
}

Fortran

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

Java

public static double code(double x, double y) {
	return Math.pow(y, 4.0);
}

Python

def code(x, y):
	return math.pow(y, 4.0)

Julia

function code(x, y)
	return y ^ 4.0
end

MATLAB

function tmp = code(x, y)
	tmp = y ^ 4.0;
end

Wolfram

code[x_, y_] := N[Power[y, 4.0], $MachinePrecision]

Derivation

1. Initial program 3.1%

   \[9 \cdot {x}^{4} - \left(y \cdot y\right) \cdot \left(y \cdot y - 2\right) \]
2. Add Preprocessing

3. Taylor expanded in y around inf 1.5%

   \[\leadsto \color{blue}{-1 \cdot {y}^{4}} \]
4. Step-by-step derivation

   1. mul-1-neg 1.5%

      \[\leadsto \color{blue}{-{y}^{4}} \]

5. Simplified 1.5%

   \[\leadsto \color{blue}{-{y}^{4}} \]
6. Step-by-step derivation

   1. neg-sub0 1.5%

      \[\leadsto \color{blue}{0 - {y}^{4}} \]

   2. sub-neg 1.5%

      \[\leadsto \color{blue}{0 + \left(-{y}^{4}\right)} \]

   3. add-sqr-sqrt 0.0%

      \[\leadsto 0 + \color{blue}{\sqrt{-{y}^{4}} \cdot \sqrt{-{y}^{4}}} \]

   4. sqrt-unprod 9.6%

      \[\leadsto 0 + \color{blue}{\sqrt{\left(-{y}^{4}\right) \cdot \left(-{y}^{4}\right)}} \]

   5. sqr-neg 9.6%

      \[\leadsto 0 + \sqrt{\color{blue}{{y}^{4} \cdot {y}^{4}}} \]

   6. sqrt-unprod 9.6%

      \[\leadsto 0 + \color{blue}{\sqrt{{y}^{4}} \cdot \sqrt{{y}^{4}}} \]

   7. add-sqr-sqrt 9.6%

      \[\leadsto 0 + \color{blue}{{y}^{4}} \]

7. Applied egg-rr 9.6%

   \[\leadsto \color{blue}{0 + {y}^{4}} \]
8. Step-by-step derivation

   1. +-lft-identity 9.6%

      \[\leadsto \color{blue}{{y}^{4}} \]

9. Simplified 9.6%

   \[\leadsto \color{blue}{{y}^{4}} \]
10. Add Preprocessing

Reproduce

herbie shell --seed 2024132 
(FPCore (x y)
  :name "From Rump in a 1983 paper, rewritten"
  :precision binary64
  :pre (and (== x 10864.0) (== y 18817.0))
  (- (* 9.0 (pow x 4.0)) (* (* y y) (- (* y y) 2.0))))