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

Percentage Accurate: 94.5% → 99.9%

Time: 4.6s

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.5% 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.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 95.8%

   \[\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 2: 93.5% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{x}{y \cdot y}\\ t_1 := t\_0 - 3\\ \mathbf{if}\;t\_1 \leq -20000000 \lor \neg \left(t\_1 \leq -2\right):\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;-3\\ \end{array} \end{array} \]

FPCore

(FPCore (x y)
 :precision binary64
 (let* ((t_0 (/ x (* y y))) (t_1 (- t_0 3.0)))
   (if (or (<= t_1 -20000000.0) (not (<= t_1 -2.0))) t_0 -3.0)))

C

double code(double x, double y) {
	double t_0 = x / (y * y);
	double t_1 = t_0 - 3.0;
	double tmp;
	if ((t_1 <= -20000000.0) || !(t_1 <= -2.0)) {
		tmp = t_0;
	} else {
		tmp = -3.0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x / (y * y)
    t_1 = t_0 - 3.0d0
    if ((t_1 <= (-20000000.0d0)) .or. (.not. (t_1 <= (-2.0d0)))) then
        tmp = t_0
    else
        tmp = -3.0d0
    end if
    code = tmp
end function

Java

public static double code(double x, double y) {
	double t_0 = x / (y * y);
	double t_1 = t_0 - 3.0;
	double tmp;
	if ((t_1 <= -20000000.0) || !(t_1 <= -2.0)) {
		tmp = t_0;
	} else {
		tmp = -3.0;
	}
	return tmp;
}

Python

def code(x, y):
	t_0 = x / (y * y)
	t_1 = t_0 - 3.0
	tmp = 0
	if (t_1 <= -20000000.0) or not (t_1 <= -2.0):
		tmp = t_0
	else:
		tmp = -3.0
	return tmp

Julia

function code(x, y)
	t_0 = Float64(x / Float64(y * y))
	t_1 = Float64(t_0 - 3.0)
	tmp = 0.0
	if ((t_1 <= -20000000.0) || !(t_1 <= -2.0))
		tmp = t_0;
	else
		tmp = -3.0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y)
	t_0 = x / (y * y);
	t_1 = t_0 - 3.0;
	tmp = 0.0;
	if ((t_1 <= -20000000.0) || ~((t_1 <= -2.0)))
		tmp = t_0;
	else
		tmp = -3.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_] := Block[{t$95$0 = N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - 3.0), $MachinePrecision]}, If[Or[LessEqual[t$95$1, -20000000.0], N[Not[LessEqual[t$95$1, -2.0]], $MachinePrecision]], t$95$0, -3.0]]]

Derivation

1. Split input into 2 regimes

2. if (-.f64 (/.f64 x (*.f64 y y)) #s(literal 3 binary64)) < -2e7 or -2 < (-.f64 (/.f64 x (*.f64 y y)) #s(literal 3 binary64))

   1. Initial program 92.5%

      \[\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. flip-- N/A

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

      3. lower-/.f64 N/A

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

      4. lower--.f64 N/A

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

      5. lift-/.f64 N/A

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

      6. lift-/.f64 N/A

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

      7. frac-times N/A

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

      8. associate-/l* N/A

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

      9. lower-*.f64 N/A

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

      10. lower-/.f64 N/A

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

      11. pow2 N/A

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

      12. lift-*.f64 N/A

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

      13. pow-prod-down N/A

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

      14. pow-prod-up N/A

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

      15. lower-pow.f64 N/A

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

      16. metadata-eval N/A

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

      17. metadata-eval N/A

          \[\leadsto \frac{x \cdot \frac{x}{{y}^{4}} - \color{blue}{9}}{\frac{x}{y \cdot y} + 3} \]

      18. +-commutative N/A

          \[\leadsto \frac{x \cdot \frac{x}{{y}^{4}} - 9}{\color{blue}{3 + \frac{x}{y \cdot y}}} \]

      19. lower-+.f64 11.3

          \[\leadsto \frac{x \cdot \frac{x}{{y}^{4}} - 9}{\color{blue}{3 + \frac{x}{y \cdot y}}} \]

      20. lift-/.f64 N/A

          \[\leadsto \frac{x \cdot \frac{x}{{y}^{4}} - 9}{3 + \color{blue}{\frac{x}{y \cdot y}}} \]

      21. lift-*.f64 N/A

          \[\leadsto \frac{x \cdot \frac{x}{{y}^{4}} - 9}{3 + \frac{x}{\color{blue}{y \cdot y}}} \]

   4. Applied rewrites 11.9%

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

      1. lift-*.f64 N/A

         \[\leadsto \frac{\color{blue}{x \cdot \frac{x}{{y}^{4}}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

      2. lift-/.f64 N/A

         \[\leadsto \frac{x \cdot \color{blue}{\frac{x}{{y}^{4}}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

      3. associate-*r/ N/A

         \[\leadsto \frac{\color{blue}{\frac{x \cdot x}{{y}^{4}}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

      4. lift-pow.f64 N/A

         \[\leadsto \frac{\frac{x \cdot x}{\color{blue}{{y}^{4}}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

      5. metadata-eval N/A

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

      6. pow-plus N/A

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

      7. unpow3 N/A

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

      8. associate-*r* N/A

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

      9. frac-times N/A

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

      10. associate-/r* N/A

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

      11. lift-/.f64 N/A

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

      12. associate-/r* N/A

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

      13. lift-/.f64 N/A

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

      14. lift-/.f64 N/A

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

      15. associate-*l/ N/A

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

      16. unpow1 N/A

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

      17. metadata-eval N/A

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

      18. pow-pow N/A

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

      19. pow2 N/A

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

      20. pow1/2 N/A

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

      21. rem-sqrt-square-rev N/A

          \[\leadsto \frac{\frac{\frac{x}{y} \cdot \frac{\frac{x}{y}}{y}}{\color{blue}{\left|y\right|}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

      22. lower-/.f64 N/A

          \[\leadsto \frac{\color{blue}{\frac{\frac{x}{y} \cdot \frac{\frac{x}{y}}{y}}{\left|y\right|}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]

   6. Applied rewrites 21.3%

      \[\leadsto \frac{\color{blue}{\frac{\frac{{\left(\frac{x}{y}\right)}^{2}}{y}}{y}} - 9}{3 + \frac{\frac{x}{y}}{y}} \]
   7. Step-by-step derivation

      1. lift-pow.f64 N/A

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

      2. unpow2 N/A

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

      3. lower-*.f64 21.3

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

   8. Applied rewrites 21.3%

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

   9. Taylor expanded in x around inf

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

       1. lower-/.f64 N/A

          \[\leadsto \color{blue}{\frac{x}{{y}^{2}}} \]

       2. unpow2 N/A

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

       3. lower-*.f64 91.4

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

   11. Applied rewrites 91.4%

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

   if -2e7 < (-.f64 (/.f64 x (*.f64 y y)) #s(literal 3 binary64)) < -2

   1. Initial program 100.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 98.9%

      \[\leadsto \color{blue}{-3} \]
3. Recombined 2 regimes into one program.

4. Final simplification 94.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{x}{y \cdot y} - 3 \leq -20000000 \lor \neg \left(\frac{x}{y \cdot y} - 3 \leq -2\right):\\ \;\;\;\;\frac{x}{y \cdot y}\\ \mathbf{else}:\\ \;\;\;\;-3\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 94.5% 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 95.8%

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

Alternative 4: 51.1% 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 95.8%

   \[\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 45.4%

   \[\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 2024339 
(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))