Statistics.Sample:$skurtosis from math-functions-0.1.5.2

Percentage Accurate: 94.0% → 99.9%

Time: 4.1s

Alternatives: 4

Speedup: 1.0×

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

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 94.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.9% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ {\left(\frac{y}{x} \cdot y\right)}^{-1} - 3 \end{array} \]

FPCore

(FPCore (x y) :precision binary64 (- (pow (* (/ y x) y) -1.0) 3.0))

C

double code(double x, double y) {
	return pow(((y / x) * y), -1.0) - 3.0;
}

Fortran

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

Java

public static double code(double x, double y) {
	return Math.pow(((y / x) * y), -1.0) - 3.0;
}

Python

def code(x, y):
	return math.pow(((y / x) * y), -1.0) - 3.0

Julia

function code(x, y)
	return Float64((Float64(Float64(y / x) * y) ^ -1.0) - 3.0)
end

MATLAB

function tmp = code(x, y)
	tmp = (((y / x) * y) ^ -1.0) - 3.0;
end

Wolfram

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

Derivation

1. Initial program 96.0%

   \[\frac{x}{y \cdot y} - 3 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-/.f64 N/A

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

   2. clear-num N/A

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

   3. frac-2neg N/A

      \[\leadsto \color{blue}{\frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(\frac{y \cdot y}{x}\right)}} - 3 \]

   4. metadata-eval N/A

      \[\leadsto \frac{\color{blue}{-1}}{\mathsf{neg}\left(\frac{y \cdot y}{x}\right)} - 3 \]

   5. lower-/.f64 N/A

      \[\leadsto \color{blue}{\frac{-1}{\mathsf{neg}\left(\frac{y \cdot y}{x}\right)}} - 3 \]

   6. lift-*.f64 N/A

      \[\leadsto \frac{-1}{\mathsf{neg}\left(\frac{\color{blue}{y \cdot y}}{x}\right)} - 3 \]

   7. associate-/l* N/A

      \[\leadsto \frac{-1}{\mathsf{neg}\left(\color{blue}{y \cdot \frac{y}{x}}\right)} - 3 \]

   8. distribute-lft-neg-in N/A

      \[\leadsto \frac{-1}{\color{blue}{\left(\mathsf{neg}\left(y\right)\right) \cdot \frac{y}{x}}} - 3 \]

   9. lower-*.f64 N/A

      \[\leadsto \frac{-1}{\color{blue}{\left(\mathsf{neg}\left(y\right)\right) \cdot \frac{y}{x}}} - 3 \]

   10. lower-neg.f64 N/A

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

   11. lower-/.f64 99.9

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

4. Applied rewrites 99.9%

   \[\leadsto \color{blue}{\frac{-1}{\left(-y\right) \cdot \frac{y}{x}}} - 3 \]
5. Step-by-step derivation

   1. lift-/.f64 N/A

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

   2. metadata-eval N/A

      \[\leadsto \frac{\color{blue}{\mathsf{neg}\left(1\right)}}{\left(-y\right) \cdot \frac{y}{x}} - 3 \]

   3. lift-*.f64 N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\color{blue}{\left(-y\right) \cdot \frac{y}{x}}} - 3 \]

   4. lift-neg.f64 N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\color{blue}{\left(\mathsf{neg}\left(y\right)\right)} \cdot \frac{y}{x}} - 3 \]

   5. distribute-lft-neg-out N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\color{blue}{\mathsf{neg}\left(y \cdot \frac{y}{x}\right)}} - 3 \]

   6. lift-/.f64 N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(y \cdot \color{blue}{\frac{y}{x}}\right)} - 3 \]

   7. associate-/l* N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(\color{blue}{\frac{y \cdot y}{x}}\right)} - 3 \]

   8. lift-*.f64 N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(\frac{\color{blue}{y \cdot y}}{x}\right)} - 3 \]

   9. lift-/.f64 N/A

      \[\leadsto \frac{\mathsf{neg}\left(1\right)}{\mathsf{neg}\left(\color{blue}{\frac{y \cdot y}{x}}\right)} - 3 \]

   10. frac-2neg N/A

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

   11. lift-/.f64 96.0

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

   12. lift-/.f64 N/A

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

   13. lift-*.f64 N/A

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

   14. associate-/l* N/A

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

   15. lift-/.f64 N/A

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

   16. *-commutative N/A

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

   17. lower-*.f64 99.9

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

6. Applied rewrites 99.9%

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

7. Final simplification 99.9%

   \[\leadsto {\left(\frac{y}{x} \cdot y\right)}^{-1} - 3 \]
8. Add Preprocessing

Alternative 2: 99.9% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (- (/ (/ x y) y) 3.0))

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return ((x / y) / y) - 3.0

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.0%

   \[\frac{x}{y \cdot y} - 3 \]
2. Add Preprocessing
3. Step-by-step derivation

   1. lift-/.f64 N/A

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

   2. lift-*.f64 N/A

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

   3. associate-/r* N/A

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

   4. lower-/.f64 N/A

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

   5. lower-/.f64 99.9

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

4. Applied rewrites 99.9%

   \[\leadsto \color{blue}{\frac{\frac{x}{y}}{y}} - 3 \]
5. Add Preprocessing

Alternative 3: 94.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.0%

   \[\frac{x}{y \cdot y} - 3 \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 4: 51.2% accurate, 20.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return -3.0

Julia

function code(x, y)
	return -3.0
end

MATLAB

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

Wolfram

code[x_, y_] := -3.0

Derivation

1. Initial program 96.0%

   \[\frac{x}{y \cdot y} - 3 \]
2. Add Preprocessing

3. Taylor expanded in x around 0

   \[\leadsto \color{blue}{-3} \]
4. Step-by-step derivation

5. Applied rewrites 54.2%

   \[\leadsto \color{blue}{-3} \]
6. Add Preprocessing

Developer Target 1: 99.9% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (- (/ (/ x y) y) 3.0))

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return ((x / y) / y) - 3.0

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024324 
(FPCore (x y)
  :name "Statistics.Sample:$skurtosis from math-functions-0.1.5.2"
  :precision binary64

  :alt
  (! :herbie-platform default (- (/ (/ x y) y) 3))

  (- (/ x (* y y)) 3.0))