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

Percentage Accurate: 95.1% → 99.9%

Time: 9.9s

Alternatives: 3

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: 95.1% 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, 1.0× 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 94.1%

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

   1. associate-/r* 99.9%

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

   2. div-inv 99.8%

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

3. Applied egg-rr 99.8%

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

4. Taylor expanded in x around 0 94.1%

   \[\leadsto \color{blue}{\frac{x}{{y}^{2}}} - 3 \]
5. Step-by-step derivation

   1. unpow2 94.1%

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

   2. associate-/r* 99.9%

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

6. Simplified 99.9%

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

7. Final simplification 99.9%

   \[\leadsto \frac{\frac{x}{y}}{y} + -3 \]

Alternative 2: 95.1% 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 94.1%

   \[\frac{x}{y \cdot y} - 3 \]

2. Final simplification 94.1%

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

Alternative 3: 51.4% accurate, 7.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 94.1%

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

   1. associate-/r* 99.9%

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

   2. div-inv 99.8%

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

3. Applied egg-rr 99.8%

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

   1. un-div-inv 99.9%

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

   2. clear-num 99.8%

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

   3. associate-/l/ 99.8%

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

5. Applied egg-rr 99.8%

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

   1. inv-pow 99.8%

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

   2. *-commutative 99.8%

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

   3. associate-/r/ 99.8%

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

   4. metadata-eval 99.8%

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

   5. sqr-pow 61.2%

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

   6. pow-prod-down 66.2%

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

   7. associate-/r/ 66.2%

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

   8. *-commutative 66.2%

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

   9. associate-/r/ 66.2%

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

   10. *-commutative 66.2%

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

   11. metadata-eval 66.2%

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

   12. metadata-eval 66.2%

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

7. Applied egg-rr 66.2%

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

   1. associate-*l* 65.9%

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

9. Simplified 65.9%

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

10. Taylor expanded in y around inf 27.2%

    \[\leadsto \color{blue}{e^{-0.5 \cdot \left(\log \left(\frac{1}{{x}^{2}}\right) + -4 \cdot \log \left(\frac{1}{y}\right)\right)}} - 3 \]

12. Simplified 50.1%

    \[\leadsto \color{blue}{0} - 3 \]

13. Final simplification 50.1%

    \[\leadsto -3 \]

Developer target: 99.9% accurate, 1.0× 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 2023297 
(FPCore (x y)
  :name "Statistics.Sample:$skurtosis from math-functions-0.1.5.2"
  :precision binary64

  :herbie-target
  (- (/ (/ x y) y) 3.0)

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