FastMath repmul

Percentage Accurate: 99.9% → 100.0%

Time: 6.0s

Alternatives: 6

Speedup: 1.0×

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

Specification

Math

\[\begin{array}{l} \\ \left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* (* (* d1 d1) d1) d1))

C

double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = ((d1 * d1) * d1) * d1
end function

Java

public static double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Python

def code(d1):
	return ((d1 * d1) * d1) * d1

Julia

function code(d1)
	return Float64(Float64(Float64(d1 * d1) * d1) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = ((d1 * d1) * d1) * d1;
end

Wolfram

code[d1_] := N[(N[(N[(d1 * d1), $MachinePrecision] * d1), $MachinePrecision] * d1), $MachinePrecision]

Initial Program: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* (* (* d1 d1) d1) d1))

C

double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = ((d1 * d1) * d1) * d1
end function

Java

public static double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Python

def code(d1):
	return ((d1 * d1) * d1) * d1

Julia

function code(d1)
	return Float64(Float64(Float64(d1 * d1) * d1) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = ((d1 * d1) * d1) * d1;
end

Wolfram

code[d1_] := N[(N[(N[(d1 * d1), $MachinePrecision] * d1), $MachinePrecision] * d1), $MachinePrecision]

Alternative 1: 100.0% accurate, 0.2× speedup

Math

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

FPCore

(FPCore (d1) :precision binary64 (pow d1 4.0))

C

double code(double d1) {
	return pow(d1, 4.0);
}

Fortran

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

Java

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

Python

def code(d1):
	return math.pow(d1, 4.0)

Julia

function code(d1)
	return d1 ^ 4.0
end

MATLAB

function tmp = code(d1)
	tmp = d1 ^ 4.0;
end

Wolfram

code[d1_] := N[Power[d1, 4.0], $MachinePrecision]

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1} \]

   2. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right)} \cdot d1 \]

   3. associate-*l* N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right)} \cdot \left(d1 \cdot d1\right) \]

   5. pow2 N/A

      \[\leadsto \color{blue}{{d1}^{2}} \cdot \left(d1 \cdot d1\right) \]

   6. pow2 N/A

      \[\leadsto {d1}^{2} \cdot \color{blue}{{d1}^{2}} \]

   7. pow-prod-up N/A

      \[\leadsto \color{blue}{{d1}^{\left(2 + 2\right)}} \]

   8. lower-pow.f64 N/A

      \[\leadsto \color{blue}{{d1}^{\left(2 + 2\right)}} \]

   9. metadata-eval 100.0

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

4. Applied rewrites 100.0%

   \[\leadsto \color{blue}{{d1}^{4}} \]
5. Add Preprocessing

Alternative 2: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* (* (* d1 d1) d1) d1))

C

double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = ((d1 * d1) * d1) * d1
end function

Java

public static double code(double d1) {
	return ((d1 * d1) * d1) * d1;
}

Python

def code(d1):
	return ((d1 * d1) * d1) * d1

Julia

function code(d1)
	return Float64(Float64(Float64(d1 * d1) * d1) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = ((d1 * d1) * d1) * d1;
end

Wolfram

code[d1_] := N[(N[(N[(d1 * d1), $MachinePrecision] * d1), $MachinePrecision] * d1), $MachinePrecision]

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 3: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right) \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* (* d1 d1) (* d1 d1)))

C

double code(double d1) {
	return (d1 * d1) * (d1 * d1);
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = (d1 * d1) * (d1 * d1)
end function

Java

public static double code(double d1) {
	return (d1 * d1) * (d1 * d1);
}

Python

def code(d1):
	return (d1 * d1) * (d1 * d1)

Julia

function code(d1)
	return Float64(Float64(d1 * d1) * Float64(d1 * d1))
end

MATLAB

function tmp = code(d1)
	tmp = (d1 * d1) * (d1 * d1);
end

Wolfram

code[d1_] := N[(N[(d1 * d1), $MachinePrecision] * N[(d1 * d1), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1} \]

   2. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right)} \cdot d1 \]

   3. associate-*l* N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   5. lower-*.f64 99.8

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

4. Applied rewrites 99.8%

   \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]
5. Add Preprocessing

Alternative 4: 52.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \left(d1 \cdot d1\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* (* d1 d1) d1))

C

double code(double d1) {
	return (d1 * d1) * d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = (d1 * d1) * d1
end function

Java

public static double code(double d1) {
	return (d1 * d1) * d1;
}

Python

def code(d1):
	return (d1 * d1) * d1

Julia

function code(d1)
	return Float64(Float64(d1 * d1) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = (d1 * d1) * d1;
end

Wolfram

code[d1_] := N[(N[(d1 * d1), $MachinePrecision] * d1), $MachinePrecision]

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1} \]

   2. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right)} \cdot d1 \]

   3. associate-*l* N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   5. lower-*.f64 99.8

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

4. Applied rewrites 99.8%

   \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]
5. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   2. pow2 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{{d1}^{2}} \]

   3. metadata-eval N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot {d1}^{\color{blue}{\left(4 \cdot \frac{1}{2}\right)}} \]

   4. metadata-eval N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot {d1}^{\left(4 \cdot \color{blue}{\frac{1}{2}}\right)} \]

   5. pow-pow N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{{\left({d1}^{4}\right)}^{\left(\frac{1}{2}\right)}} \]

6. Applied rewrites 53.7%

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

Alternative 5: 53.1% accurate, 2.7× speedup

Math

\[\begin{array}{l} \\ d1 \cdot d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* d1 d1))

C

double code(double d1) {
	return d1 * d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1 * d1
end function

Java

public static double code(double d1) {
	return d1 * d1;
}

Python

def code(d1):
	return d1 * d1

Julia

function code(d1)
	return Float64(d1 * d1)
end

MATLAB

function tmp = code(d1)
	tmp = d1 * d1;
end

Wolfram

code[d1_] := N[(d1 * d1), $MachinePrecision]

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1} \]

   2. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right)} \cdot d1 \]

   3. associate-*l* N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   5. lower-*.f64 99.8

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

4. Applied rewrites 99.8%

   \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]
5. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   2. pow2 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{{d1}^{2}} \]

   3. metadata-eval N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot {d1}^{\color{blue}{\left(4 \cdot \frac{1}{2}\right)}} \]

   4. metadata-eval N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot {d1}^{\left(4 \cdot \color{blue}{\frac{1}{2}}\right)} \]

   5. pow-pow N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{{\left({d1}^{4}\right)}^{\left(\frac{1}{2}\right)}} \]

6. Applied rewrites 53.7%

   \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{d1} \]

8. Applied rewrites 55.8%

   \[\leadsto \color{blue}{d1} \cdot d1 \]
9. Add Preprocessing

Alternative 6: 4.4% accurate, 16.0× speedup

Math

\[\begin{array}{l} \\ d1 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 d1)

C

double code(double d1) {
	return d1;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1
end function

Java

public static double code(double d1) {
	return d1;
}

Python

def code(d1):
	return d1

Julia

function code(d1)
	return d1
end

MATLAB

function tmp = code(d1)
	tmp = d1;
end

Wolfram

code[d1_] := d1

Derivation

1. Initial program 99.9%

   \[\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right) \cdot d1} \]

   2. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d1\right) \cdot d1\right)} \cdot d1 \]

   3. associate-*l* N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   4. lift-*.f64 N/A

      \[\leadsto \left(d1 \cdot d1\right) \cdot \color{blue}{\left(d1 \cdot d1\right)} \]

   5. lower-*.f64 99.8

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

4. Applied rewrites 99.8%

   \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]
5. Step-by-step derivation

   1. lift-*.f64 N/A

      \[\leadsto \color{blue}{\left(d1 \cdot d1\right) \cdot \left(d1 \cdot d1\right)} \]

   2. pow2 N/A

      \[\leadsto \color{blue}{{\left(d1 \cdot d1\right)}^{2}} \]

   3. lift-*.f64 N/A

      \[\leadsto {\color{blue}{\left(d1 \cdot d1\right)}}^{2} \]

   4. unpow-prod-down N/A

      \[\leadsto \color{blue}{{d1}^{2} \cdot {d1}^{2}} \]

   5. pow-to-exp N/A

      \[\leadsto \color{blue}{e^{\log d1 \cdot 2}} \cdot {d1}^{2} \]

   6. pow-to-exp N/A

      \[\leadsto e^{\log d1 \cdot 2} \cdot \color{blue}{e^{\log d1 \cdot 2}} \]

   7. prod-exp N/A

      \[\leadsto \color{blue}{e^{\log d1 \cdot 2 + \log d1 \cdot 2}} \]

   8. flip-+ N/A

      \[\leadsto e^{\color{blue}{\frac{\left(\log d1 \cdot 2\right) \cdot \left(\log d1 \cdot 2\right) - \left(\log d1 \cdot 2\right) \cdot \left(\log d1 \cdot 2\right)}{\log d1 \cdot 2 - \log d1 \cdot 2}}} \]

   9. +-inverses N/A

      \[\leadsto e^{\frac{\color{blue}{0}}{\log d1 \cdot 2 - \log d1 \cdot 2}} \]

   10. metadata-eval N/A

       \[\leadsto e^{\frac{\color{blue}{0 \cdot \frac{1}{2}}}{\log d1 \cdot 2 - \log d1 \cdot 2}} \]

   11. +-inverses N/A

       \[\leadsto e^{\frac{\color{blue}{\left(\log d1 \cdot \log d1 - \log d1 \cdot \log d1\right)} \cdot \frac{1}{2}}{\log d1 \cdot 2 - \log d1 \cdot 2}} \]

   12. metadata-eval N/A

       \[\leadsto e^{\frac{\left(\log d1 \cdot \log d1 - \log d1 \cdot \log d1\right) \cdot \color{blue}{\frac{1}{2}}}{\log d1 \cdot 2 - \log d1 \cdot 2}} \]

   13. +-inverses N/A

       \[\leadsto e^{\frac{\left(\log d1 \cdot \log d1 - \log d1 \cdot \log d1\right) \cdot \frac{1}{2}}{\color{blue}{0}}} \]

   14. +-inverses N/A

       \[\leadsto e^{\frac{\left(\log d1 \cdot \log d1 - \log d1 \cdot \log d1\right) \cdot \frac{1}{2}}{\color{blue}{\log d1 \cdot \log d1 - \log d1 \cdot \log d1}}} \]

   15. associate-*l/ N/A

       \[\leadsto e^{\color{blue}{\frac{\log d1 \cdot \log d1 - \log d1 \cdot \log d1}{\log d1 \cdot \log d1 - \log d1 \cdot \log d1} \cdot \frac{1}{2}}} \]

6. Applied rewrites 4.4%

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

Developer Target 1: 100.0% accurate, 0.2× speedup

Math

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

FPCore

(FPCore (d1) :precision binary64 (pow d1 4.0))

C

double code(double d1) {
	return pow(d1, 4.0);
}

Fortran

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

Java

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

Python

def code(d1):
	return math.pow(d1, 4.0)

Julia

function code(d1)
	return d1 ^ 4.0
end

MATLAB

function tmp = code(d1)
	tmp = d1 ^ 4.0;
end

Wolfram

code[d1_] := N[Power[d1, 4.0], $MachinePrecision]

Reproduce

herbie shell --seed 2024288 
(FPCore (d1)
  :name "FastMath repmul"
  :precision binary64

  :alt
  (! :herbie-platform default (pow d1 4))

  (* (* (* d1 d1) d1) d1))