Statistics.Distribution.Binomial:$cvariance from math-functions-0.1.5.2

Percentage Accurate: 99.9% → 99.9%

Time: 8.1s

Alternatives: 6

Speedup: 1.0×

• 24.7% 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 \left(1 - y\right) \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

   1. flip3-- N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{{1}^{3} - {y}^{3}}{\color{blue}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}}\right)\right) \]

   2. metadata-eval N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{1 - {y}^{3}}{\color{blue}{1} \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}\right)\right) \]

   3. div-sub N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} - \color{blue}{\frac{{y}^{3}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}}\right)\right) \]

   4. div-inv N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(1 \cdot \frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} - \frac{\color{blue}{{y}^{3}}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}\right)\right) \]

   5. sqr-pow N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(1 \cdot \frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} - \frac{{y}^{\left(\frac{3}{2}\right)} \cdot {y}^{\left(\frac{3}{2}\right)}}{\color{blue}{1 \cdot 1} + \left(y \cdot y + 1 \cdot y\right)}\right)\right) \]

   6. associate-/l* N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(1 \cdot \frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} - {y}^{\left(\frac{3}{2}\right)} \cdot \color{blue}{\frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}}\right)\right) \]

   7. prod-diff N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \left(\mathsf{fma}\left(1, \frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}, \mathsf{neg}\left(\frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} \cdot {y}^{\left(\frac{3}{2}\right)}\right)\right) + \color{blue}{\mathsf{fma}\left(\mathsf{neg}\left(\frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}\right), {y}^{\left(\frac{3}{2}\right)}, \frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} \cdot {y}^{\left(\frac{3}{2}\right)}\right)}\right)\right) \]

   8. +-lowering-+.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{*.f64}\left(x, y\right), \mathsf{+.f64}\left(\left(\mathsf{fma}\left(1, \frac{1}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}, \mathsf{neg}\left(\frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} \cdot {y}^{\left(\frac{3}{2}\right)}\right)\right)\right), \color{blue}{\left(\mathsf{fma}\left(\mathsf{neg}\left(\frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)}\right), {y}^{\left(\frac{3}{2}\right)}, \frac{{y}^{\left(\frac{3}{2}\right)}}{1 \cdot 1 + \left(y \cdot y + 1 \cdot y\right)} \cdot {y}^{\left(\frac{3}{2}\right)}\right)\right)}\right)\right) \]

4. Applied egg-rr 40.9%

   \[\leadsto \left(x \cdot y\right) \cdot \color{blue}{\left(\mathsf{fma}\left(1, \frac{1}{1 + y \cdot \left(y + 1\right)}, -\frac{{y}^{1.5}}{1 + y \cdot \left(y + 1\right)} \cdot {y}^{1.5}\right) + \mathsf{fma}\left(-\frac{{y}^{1.5}}{1 + y \cdot \left(y + 1\right)}, {y}^{1.5}, \frac{{y}^{1.5}}{1 + y \cdot \left(y + 1\right)} \cdot {y}^{1.5}\right)\right)} \]
5. Step-by-step derivation

6. Applied egg-rr 99.9%

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

7. Final simplification 99.9%

   \[\leadsto y \cdot \left(\left(1 - y\right) \cdot x\right) \]
8. Add Preprocessing

Alternative 2: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

3. Final simplification 99.9%

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

Alternative 3: 94.6% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

   1. associate-*l* N/A

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

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

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

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

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

   4. --lowering--.f64 93.4%

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

3. Simplified 93.4%

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

   1. sub-neg N/A

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

   2. distribute-rgt-in N/A

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

   3. fma-define N/A

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

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

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

   5. fmm-def N/A

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

   6. *-lft-identity N/A

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

   7. --lowering--.f64 N/A

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

   8. *-lowering-*.f64 93.4%

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

6. Applied egg-rr 93.4%

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

Alternative 4: 94.6% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

   1. associate-*l* N/A

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

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

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

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

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

   4. --lowering--.f64 93.4%

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

3. Simplified 93.4%

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

Alternative 5: 57.3% accurate, 2.3× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

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

   1. associate-*l* N/A

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

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

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

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

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

   4. --lowering--.f64 93.4%

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

3. Simplified 93.4%

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

5. Taylor expanded in y around 0

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

   1. *-lowering-*.f64 58.6%

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

7. Simplified 58.6%

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

8. Final simplification 58.6%

   \[\leadsto y \cdot x \]
9. Add Preprocessing

Alternative 6: 2.9% accurate, 7.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.9%

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

   1. associate-*l* N/A

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

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

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

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

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

   4. --lowering--.f64 93.4%

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

3. Simplified 93.4%

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

6. Applied egg-rr 54.2%

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

7. Taylor expanded in y around 0

   \[\leadsto \mathsf{/.f64}\left(\color{blue}{\left(x \cdot y\right)}, \mathsf{+.f64}\left(y, 1\right)\right) \]
8. Step-by-step derivation

   1. *-lowering-*.f64 54.5%

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

9. Simplified 54.5%

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

10. Taylor expanded in y around inf

    \[\leadsto \color{blue}{x} \]
11. Step-by-step derivation

12. Simplified 3.0%

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

Reproduce

herbie shell --seed 2024160 
(FPCore (x y)
  :name "Statistics.Distribution.Binomial:$cvariance from math-functions-0.1.5.2"
  :precision binary64
  (* (* x y) (- 1.0 y)))