Data.HyperLogLog.Config:hll from hyperloglog-0.3.4

Percentage Accurate: 99.8% → 99.8%

Time: 2.7s

Alternatives: 4

Speedup: 1.0×

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

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 99.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

   \[\left(x \cdot y\right) \cdot y \]
2. Add Preprocessing

3. Final simplification 99.8%

   \[\leadsto y \cdot \left(x \cdot y\right) \]
4. Add Preprocessing

Alternative 2: 87.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

   \[\left(x \cdot y\right) \cdot y \]
2. Step-by-step derivation

   1. associate-*l* N/A

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

   2. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(x, \color{blue}{\left(y \cdot y\right)}\right) \]

   3. *-lowering-*.f64 84.9%

      \[\leadsto \mathsf{*.f64}\left(x, \mathsf{*.f64}\left(y, \color{blue}{y}\right)\right) \]

3. Simplified 84.9%

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

Alternative 3: 21.2% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

   \[\left(x \cdot y\right) \cdot y \]
2. Step-by-step derivation

   1. associate-*l* N/A

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

   2. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(x, \color{blue}{\left(y \cdot y\right)}\right) \]

   3. *-lowering-*.f64 84.9%

      \[\leadsto \mathsf{*.f64}\left(x, \mathsf{*.f64}\left(y, \color{blue}{y}\right)\right) \]

3. Simplified 84.9%

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

   1. pow2 N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left({y}^{\color{blue}{2}}\right)\right) \]

   2. pow-to-exp N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log y \cdot 2}\right)\right) \]

   3. *-commutative N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{2 \cdot \log y}\right)\right) \]

   4. count-2 N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log y + \log y}\right)\right) \]

   5. flip-+ N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\frac{\log y \cdot \log y - \log y \cdot \log y}{\log y - \log y}}\right)\right) \]

   6. +-inverses N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\frac{0}{\log y - \log y}}\right)\right) \]

   7. +-inverses N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\frac{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) - \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}{\log y - \log y}}\right)\right) \]

   8. +-inverses N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\frac{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) - \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}{0}}\right)\right) \]

   9. +-inverses N/A

      \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\frac{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) - \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) \cdot \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) - \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}}\right)\right) \]

   10. flip-+ N/A

       \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right) + \log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}\right)\right) \]

   11. log-prod N/A

       \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log \left({y}^{\left(\frac{\frac{2}{2}}{2}\right)} \cdot {y}^{\left(\frac{\frac{2}{2}}{2}\right)}\right)}\right)\right) \]

   12. sqr-pow N/A

       \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log \left({y}^{\left(\frac{2}{2}\right)}\right)}\right)\right) \]

   13. metadata-eval N/A

       \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log \left({y}^{1}\right)}\right)\right) \]

   14. unpow1 N/A

       \[\leadsto \mathsf{*.f64}\left(x, \left(e^{\log y}\right)\right) \]

   15. rem-exp-log 18.4%

       \[\leadsto \mathsf{*.f64}\left(x, y\right) \]

6. Applied egg-rr 18.4%

   \[\leadsto x \cdot \color{blue}{y} \]
7. Add Preprocessing

Alternative 4: 5.0% accurate, 5.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 x)

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return x

Julia

function code(x, y)
	return x
end

MATLAB

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

Wolfram

code[x_, y_] := x

Derivation

1. Initial program 99.8%

   \[\left(x \cdot y\right) \cdot y \]
2. Step-by-step derivation

   1. associate-*l* N/A

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

   2. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(x, \color{blue}{\left(y \cdot y\right)}\right) \]

   3. *-lowering-*.f64 84.9%

      \[\leadsto \mathsf{*.f64}\left(x, \mathsf{*.f64}\left(y, \color{blue}{y}\right)\right) \]

3. Simplified 84.9%

   \[\leadsto \color{blue}{x \cdot \left(y \cdot y\right)} \]
4. Add Preprocessing

6. Applied egg-rr 4.9%

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

Reproduce

herbie shell --seed 2024192 
(FPCore (x y)
  :name "Data.HyperLogLog.Config:hll from hyperloglog-0.3.4"
  :precision binary64
  (* (* x y) y))