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

Percentage Accurate: 82.9% → 97.1%

Time: 10.1s

Alternatives: 9

Speedup: 1.0×

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

Specification

Math

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

FPCore

(FPCore (x y z) :precision binary64 (/ (* x y) (* (* z z) (+ z 1.0))))

C

double code(double x, double y, double z) {
	return (x * y) / ((z * z) * (z + 1.0));
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	return (x * y) / ((z * z) * (z + 1.0));
}

Python

def code(x, y, z):
	return (x * y) / ((z * z) * (z + 1.0))

Julia

function code(x, y, z)
	return Float64(Float64(x * y) / Float64(Float64(z * z) * Float64(z + 1.0)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (x * y) / ((z * z) * (z + 1.0));
end

Wolfram

code[x_, y_, z_] := N[(N[(x * y), $MachinePrecision] / N[(N[(z * z), $MachinePrecision] * N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 82.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (/ (* x y) (* (* z z) (+ z 1.0))))

C

double code(double x, double y, double z) {
	return (x * y) / ((z * z) * (z + 1.0));
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	return (x * y) / ((z * z) * (z + 1.0));
}

Python

def code(x, y, z):
	return (x * y) / ((z * z) * (z + 1.0))

Julia

function code(x, y, z)
	return Float64(Float64(x * y) / Float64(Float64(z * z) * Float64(z + 1.0)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (x * y) / ((z * z) * (z + 1.0));
end

Wolfram

code[x_, y_, z_] := N[(N[(x * y), $MachinePrecision] / N[(N[(z * z), $MachinePrecision] * N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 97.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \frac{\frac{x}{z} \cdot \frac{y}{z + 1}}{z} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z) :precision binary64 (/ (* (/ x z) (/ y (+ z 1.0))) z))

C

assert(x < y);
double code(double x, double y, double z) {
	return ((x / z) * (y / (z + 1.0))) / z;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((x / z) * (y / (z + 1.0d0))) / z
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	return ((x / z) * (y / (z + 1.0))) / z;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	return ((x / z) * (y / (z + 1.0))) / z

Julia

x, y = sort([x, y])
function code(x, y, z)
	return Float64(Float64(Float64(x / z) * Float64(y / Float64(z + 1.0))) / z)
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
	tmp = ((x / z) * (y / (z + 1.0))) / z;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := N[(N[(N[(x / z), $MachinePrecision] * N[(y / N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
2. Step-by-step derivation

   1. times-frac 88.4%

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

   2. associate-/r* 93.9%

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

3. Simplified 93.9%

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

   1. associate-*l/ 96.7%

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

5. Applied egg-rr 96.7%

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

6. Final simplification 96.7%

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

Alternative 2: 94.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 3.2 \cdot 10^{-16}\right):\\ \;\;\;\;\frac{x}{z} \cdot \frac{\frac{y}{z}}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (or (<= z -1.0) (not (<= z 3.2e-16)))
   (* (/ x z) (/ (/ y z) z))
   (/ (* (/ x z) y) z)))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 3.2e-16)) {
		tmp = (x / z) * ((y / z) / z);
	} else {
		tmp = ((x / z) * y) / z;
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if ((z <= (-1.0d0)) .or. (.not. (z <= 3.2d-16))) then
        tmp = (x / z) * ((y / z) / z)
    else
        tmp = ((x / z) * y) / z
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 3.2e-16)) {
		tmp = (x / z) * ((y / z) / z);
	} else {
		tmp = ((x / z) * y) / z;
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if (z <= -1.0) or not (z <= 3.2e-16):
		tmp = (x / z) * ((y / z) / z)
	else:
		tmp = ((x / z) * y) / z
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if ((z <= -1.0) || !(z <= 3.2e-16))
		tmp = Float64(Float64(x / z) * Float64(Float64(y / z) / z));
	else
		tmp = Float64(Float64(Float64(x / z) * y) / z);
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((z <= -1.0) || ~((z <= 3.2e-16)))
		tmp = (x / z) * ((y / z) / z);
	else
		tmp = ((x / z) * y) / z;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, 3.2e-16]], $MachinePrecision]], N[(N[(x / z), $MachinePrecision] * N[(N[(y / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], N[(N[(N[(x / z), $MachinePrecision] * y), $MachinePrecision] / z), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1 or 3.20000000000000023e-16 < z

   1. Initial program 85.4%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 95.3%

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

      2. associate-*l/ 95.3%

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

      3. times-frac 95.2%

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

   3. Applied egg-rr 95.2%

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

   4. Taylor expanded in z around inf 93.4%

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

   if -1 < z < 3.20000000000000023e-16

   1. Initial program 82.0%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 81.8%

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

      2. associate-/r* 90.5%

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

   3. Simplified 90.5%

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

      1. associate-*l/ 94.6%

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

   5. Applied egg-rr 94.6%

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

   6. Taylor expanded in z around 0 92.0%

      \[\leadsto \frac{\frac{x}{z} \cdot \color{blue}{y}}{z} \]
3. Recombined 2 regimes into one program.

4. Final simplification 92.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 3.2 \cdot 10^{-16}\right):\\ \;\;\;\;\frac{x}{z} \cdot \frac{\frac{y}{z}}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \end{array} \]

Alternative 3: 94.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 1.35 \cdot 10^{-21}\right):\\ \;\;\;\;\frac{\frac{x}{z} \cdot \frac{y}{z}}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (or (<= z -1.0) (not (<= z 1.35e-21)))
   (/ (* (/ x z) (/ y z)) z)
   (/ (* (/ x z) y) z)))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 1.35e-21)) {
		tmp = ((x / z) * (y / z)) / z;
	} else {
		tmp = ((x / z) * y) / z;
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if ((z <= (-1.0d0)) .or. (.not. (z <= 1.35d-21))) then
        tmp = ((x / z) * (y / z)) / z
    else
        tmp = ((x / z) * y) / z
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 1.35e-21)) {
		tmp = ((x / z) * (y / z)) / z;
	} else {
		tmp = ((x / z) * y) / z;
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if (z <= -1.0) or not (z <= 1.35e-21):
		tmp = ((x / z) * (y / z)) / z
	else:
		tmp = ((x / z) * y) / z
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if ((z <= -1.0) || !(z <= 1.35e-21))
		tmp = Float64(Float64(Float64(x / z) * Float64(y / z)) / z);
	else
		tmp = Float64(Float64(Float64(x / z) * y) / z);
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((z <= -1.0) || ~((z <= 1.35e-21)))
		tmp = ((x / z) * (y / z)) / z;
	else
		tmp = ((x / z) * y) / z;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, 1.35e-21]], $MachinePrecision]], N[(N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision], N[(N[(N[(x / z), $MachinePrecision] * y), $MachinePrecision] / z), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1 or 1.3500000000000001e-21 < z

   1. Initial program 85.5%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 95.3%

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

      2. associate-/r* 97.4%

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

   3. Simplified 97.4%

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

      1. associate-*l/ 98.9%

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

   5. Applied egg-rr 98.9%

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

   6. Taylor expanded in z around inf 97.1%

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

   if -1 < z < 1.3500000000000001e-21

   1. Initial program 81.8%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 81.6%

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

      2. associate-/r* 90.4%

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

   3. Simplified 90.4%

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

      1. associate-*l/ 94.5%

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

   5. Applied egg-rr 94.5%

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

   6. Taylor expanded in z around 0 92.0%

      \[\leadsto \frac{\frac{x}{z} \cdot \color{blue}{y}}{z} \]
3. Recombined 2 regimes into one program.

4. Final simplification 94.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1 \lor \neg \left(z \leq 1.35 \cdot 10^{-21}\right):\\ \;\;\;\;\frac{\frac{x}{z} \cdot \frac{y}{z}}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \end{array} \]

Alternative 4: 93.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;z \leq -1:\\ \;\;\;\;\frac{y}{z} \cdot \frac{x}{z \cdot z}\\ \mathbf{elif}\;z \leq 3.2 \cdot 10^{-16}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{\frac{y}{z}}{z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (<= z -1.0)
   (* (/ y z) (/ x (* z z)))
   (if (<= z 3.2e-16) (/ (* (/ x z) y) z) (* (/ x z) (/ (/ y z) z)))))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.0) {
		tmp = (y / z) * (x / (z * z));
	} else if (z <= 3.2e-16) {
		tmp = ((x / z) * y) / z;
	} else {
		tmp = (x / z) * ((y / z) / z);
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= (-1.0d0)) then
        tmp = (y / z) * (x / (z * z))
    else if (z <= 3.2d-16) then
        tmp = ((x / z) * y) / z
    else
        tmp = (x / z) * ((y / z) / z)
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.0) {
		tmp = (y / z) * (x / (z * z));
	} else if (z <= 3.2e-16) {
		tmp = ((x / z) * y) / z;
	} else {
		tmp = (x / z) * ((y / z) / z);
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if z <= -1.0:
		tmp = (y / z) * (x / (z * z))
	elif z <= 3.2e-16:
		tmp = ((x / z) * y) / z
	else:
		tmp = (x / z) * ((y / z) / z)
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if (z <= -1.0)
		tmp = Float64(Float64(y / z) * Float64(x / Float64(z * z)));
	elseif (z <= 3.2e-16)
		tmp = Float64(Float64(Float64(x / z) * y) / z);
	else
		tmp = Float64(Float64(x / z) * Float64(Float64(y / z) / z));
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1.0)
		tmp = (y / z) * (x / (z * z));
	elseif (z <= 3.2e-16)
		tmp = ((x / z) * y) / z;
	else
		tmp = (x / z) * ((y / z) / z);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[LessEqual[z, -1.0], N[(N[(y / z), $MachinePrecision] * N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 3.2e-16], N[(N[(N[(x / z), $MachinePrecision] * y), $MachinePrecision] / z), $MachinePrecision], N[(N[(x / z), $MachinePrecision] * N[(N[(y / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if z < -1

   1. Initial program 84.9%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 97.2%

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

   3. Simplified 97.2%

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

   4. Taylor expanded in z around inf 94.5%

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

   if -1 < z < 3.20000000000000023e-16

   1. Initial program 82.0%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 81.8%

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

      2. associate-/r* 90.5%

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

   3. Simplified 90.5%

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

      1. associate-*l/ 94.6%

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

   5. Applied egg-rr 94.6%

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

   6. Taylor expanded in z around 0 92.0%

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

   if 3.20000000000000023e-16 < z

   1. Initial program 85.9%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 93.6%

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

      2. associate-*l/ 93.0%

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

      3. times-frac 93.6%

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

   3. Applied egg-rr 93.6%

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

   4. Taylor expanded in z around inf 92.6%

      \[\leadsto \frac{x}{z} \cdot \frac{\color{blue}{\frac{y}{z}}}{z} \]
3. Recombined 3 regimes into one program.

4. Final simplification 92.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1:\\ \;\;\;\;\frac{y}{z} \cdot \frac{x}{z \cdot z}\\ \mathbf{elif}\;z \leq 3.2 \cdot 10^{-16}:\\ \;\;\;\;\frac{\frac{x}{z} \cdot y}{z}\\ \mathbf{else}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{\frac{y}{z}}{z}\\ \end{array} \]

Alternative 5: 96.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \frac{x}{z} \cdot \frac{\frac{y}{z + 1}}{z} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z) :precision binary64 (* (/ x z) (/ (/ y (+ z 1.0)) z)))

C

assert(x < y);
double code(double x, double y, double z) {
	return (x / z) * ((y / (z + 1.0)) / z);
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (x / z) * ((y / (z + 1.0d0)) / z)
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	return (x / z) * ((y / (z + 1.0)) / z);
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	return (x / z) * ((y / (z + 1.0)) / z)

Julia

x, y = sort([x, y])
function code(x, y, z)
	return Float64(Float64(x / z) * Float64(Float64(y / Float64(z + 1.0)) / z))
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
	tmp = (x / z) * ((y / (z + 1.0)) / z);
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := N[(N[(x / z), $MachinePrecision] * N[(N[(y / N[(z + 1.0), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
2. Step-by-step derivation

   1. times-frac 88.4%

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

   2. associate-*l/ 88.5%

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

   3. times-frac 95.0%

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

3. Applied egg-rr 95.0%

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

4. Final simplification 95.0%

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

Alternative 6: 76.8% accurate, 1.2× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;y \leq 5.6 \cdot 10^{-35}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{x}{z \cdot z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (<= y 5.6e-35) (* (/ x z) (/ y z)) (* y (/ x (* z z)))))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if (y <= 5.6e-35) {
		tmp = (x / z) * (y / z);
	} else {
		tmp = y * (x / (z * z));
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y <= 5.6d-35) then
        tmp = (x / z) * (y / z)
    else
        tmp = y * (x / (z * z))
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 5.6e-35) {
		tmp = (x / z) * (y / z);
	} else {
		tmp = y * (x / (z * z));
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if y <= 5.6e-35:
		tmp = (x / z) * (y / z)
	else:
		tmp = y * (x / (z * z))
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if (y <= 5.6e-35)
		tmp = Float64(Float64(x / z) * Float64(y / z));
	else
		tmp = Float64(y * Float64(x / Float64(z * z)));
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 5.6e-35)
		tmp = (x / z) * (y / z);
	else
		tmp = y * (x / (z * z));
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[LessEqual[y, 5.6e-35], N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(y * N[(x / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 5.5999999999999999e-35

   1. Initial program 82.7%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 86.5%

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

      2. associate-*l/ 86.8%

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

      3. times-frac 93.5%

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

   3. Applied egg-rr 93.5%

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

   4. Taylor expanded in z around 0 75.1%

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

   if 5.5999999999999999e-35 < y

   1. Initial program 86.2%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 93.6%

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

   3. Simplified 93.6%

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

   4. Taylor expanded in z around 0 71.5%

      \[\leadsto \frac{x}{z \cdot z} \cdot \color{blue}{y} \]
3. Recombined 2 regimes into one program.

4. Final simplification 74.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 5.6 \cdot 10^{-35}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{x}{z \cdot z}\\ \end{array} \]

Alternative 7: 77.0% accurate, 1.2× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;y \leq 1.5 \cdot 10^{+28}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{\frac{x}{z}}{z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (<= y 1.5e+28) (* (/ x z) (/ y z)) (* y (/ (/ x z) z))))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if (y <= 1.5e+28) {
		tmp = (x / z) * (y / z);
	} else {
		tmp = y * ((x / z) / z);
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y <= 1.5d+28) then
        tmp = (x / z) * (y / z)
    else
        tmp = y * ((x / z) / z)
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 1.5e+28) {
		tmp = (x / z) * (y / z);
	} else {
		tmp = y * ((x / z) / z);
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if y <= 1.5e+28:
		tmp = (x / z) * (y / z)
	else:
		tmp = y * ((x / z) / z)
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if (y <= 1.5e+28)
		tmp = Float64(Float64(x / z) * Float64(y / z));
	else
		tmp = Float64(y * Float64(Float64(x / z) / z));
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 1.5e+28)
		tmp = (x / z) * (y / z);
	else
		tmp = y * ((x / z) / z);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[LessEqual[y, 1.5e+28], N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 1.5e28

   1. Initial program 83.2%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 87.1%

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

      2. associate-*l/ 87.0%

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

      3. times-frac 94.1%

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

   3. Applied egg-rr 94.1%

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

   4. Taylor expanded in z around 0 74.9%

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

   if 1.5e28 < y

   1. Initial program 85.4%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 93.3%

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

      2. associate-/r* 95.1%

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

   3. Simplified 95.1%

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

   4. Taylor expanded in z around 0 69.2%

      \[\leadsto \frac{\frac{x}{z}}{z} \cdot \color{blue}{y} \]
3. Recombined 2 regimes into one program.

4. Final simplification 73.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 1.5 \cdot 10^{+28}:\\ \;\;\;\;\frac{x}{z} \cdot \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{\frac{x}{z}}{z}\\ \end{array} \]

Alternative 8: 78.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \begin{array}{l} \mathbf{if}\;y \leq 4.3 \cdot 10^{+18}:\\ \;\;\;\;\frac{x}{z \cdot \frac{z}{y}}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{\frac{x}{z}}{z}\\ \end{array} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z)
 :precision binary64
 (if (<= y 4.3e+18) (/ x (* z (/ z y))) (* y (/ (/ x z) z))))

C

assert(x < y);
double code(double x, double y, double z) {
	double tmp;
	if (y <= 4.3e+18) {
		tmp = x / (z * (z / y));
	} else {
		tmp = y * ((x / z) / z);
	}
	return tmp;
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (y <= 4.3d+18) then
        tmp = x / (z * (z / y))
    else
        tmp = y * ((x / z) / z)
    end if
    code = tmp
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 4.3e+18) {
		tmp = x / (z * (z / y));
	} else {
		tmp = y * ((x / z) / z);
	}
	return tmp;
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	tmp = 0
	if y <= 4.3e+18:
		tmp = x / (z * (z / y))
	else:
		tmp = y * ((x / z) / z)
	return tmp

Julia

x, y = sort([x, y])
function code(x, y, z)
	tmp = 0.0
	if (y <= 4.3e+18)
		tmp = Float64(x / Float64(z * Float64(z / y)));
	else
		tmp = Float64(y * Float64(Float64(x / z) / z));
	end
	return tmp
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 4.3e+18)
		tmp = x / (z * (z / y));
	else
		tmp = y * ((x / z) / z);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := If[LessEqual[y, 4.3e+18], N[(x / N[(z * N[(z / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(y * N[(N[(x / z), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 4.3e18

   1. Initial program 83.4%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 87.4%

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

   3. Simplified 87.4%

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

   4. Taylor expanded in z around 0 69.7%

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

      1. associate-*l/ 69.4%

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

      2. times-frac 75.3%

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

      3. clear-num 76.2%

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

      4. frac-times 76.8%

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

      5. *-commutative 76.8%

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

      6. *-un-lft-identity 76.8%

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

   6. Applied egg-rr 76.8%

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

   if 4.3e18 < y

   1. Initial program 84.5%

      \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
   2. Step-by-step derivation

      1. times-frac 92.0%

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

      2. associate-/r* 95.3%

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

   3. Simplified 95.3%

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

   4. Taylor expanded in z around 0 67.9%

      \[\leadsto \frac{\frac{x}{z}}{z} \cdot \color{blue}{y} \]
3. Recombined 2 regimes into one program.

4. Final simplification 74.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 4.3 \cdot 10^{+18}:\\ \;\;\;\;\frac{x}{z \cdot \frac{z}{y}}\\ \mathbf{else}:\\ \;\;\;\;y \cdot \frac{\frac{x}{z}}{z}\\ \end{array} \]

Alternative 9: 73.6% accurate, 1.6× speedup

Math

\[\begin{array}{l} [x, y] = \mathsf{sort}([x, y])\\ \\ \frac{x}{z} \cdot \frac{y}{z} \end{array} \]

FPCore

NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y z) :precision binary64 (* (/ x z) (/ y z)))

C

assert(x < y);
double code(double x, double y, double z) {
	return (x / z) * (y / z);
}

Fortran

NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (x / z) * (y / z)
end function

Java

assert x < y;
public static double code(double x, double y, double z) {
	return (x / z) * (y / z);
}

Python

[x, y] = sort([x, y])
def code(x, y, z):
	return (x / z) * (y / z)

Julia

x, y = sort([x, y])
function code(x, y, z)
	return Float64(Float64(x / z) * Float64(y / z))
end

MATLAB

x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y, z)
	tmp = (x / z) * (y / z);
end

Wolfram

NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_, z_] := N[(N[(x / z), $MachinePrecision] * N[(y / z), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 83.7%

   \[\frac{x \cdot y}{\left(z \cdot z\right) \cdot \left(z + 1\right)} \]
2. Step-by-step derivation

   1. times-frac 88.4%

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

   2. associate-*l/ 88.5%

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

   3. times-frac 95.0%

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

3. Applied egg-rr 95.0%

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

4. Taylor expanded in z around 0 71.9%

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

5. Final simplification 71.9%

   \[\leadsto \frac{x}{z} \cdot \frac{y}{z} \]

Developer target: 95.4% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z < 249.6182814532307:\\ \;\;\;\;\frac{y \cdot \frac{x}{z}}{z + z \cdot z}\\ \mathbf{else}:\\ \;\;\;\;\frac{\frac{\frac{y}{z}}{1 + z} \cdot x}{z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (< z 249.6182814532307)
   (/ (* y (/ x z)) (+ z (* z z)))
   (/ (* (/ (/ y z) (+ 1.0 z)) x) z)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z < 249.6182814532307) {
		tmp = (y * (x / z)) / (z + (z * z));
	} else {
		tmp = (((y / z) / (1.0 + z)) * x) / z;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z < 249.6182814532307d0) then
        tmp = (y * (x / z)) / (z + (z * z))
    else
        tmp = (((y / z) / (1.0d0 + z)) * x) / z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z < 249.6182814532307) {
		tmp = (y * (x / z)) / (z + (z * z));
	} else {
		tmp = (((y / z) / (1.0 + z)) * x) / z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z < 249.6182814532307:
		tmp = (y * (x / z)) / (z + (z * z))
	else:
		tmp = (((y / z) / (1.0 + z)) * x) / z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z < 249.6182814532307)
		tmp = Float64(Float64(y * Float64(x / z)) / Float64(z + Float64(z * z)));
	else
		tmp = Float64(Float64(Float64(Float64(y / z) / Float64(1.0 + z)) * x) / z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z < 249.6182814532307)
		tmp = (y * (x / z)) / (z + (z * z));
	else
		tmp = (((y / z) / (1.0 + z)) * x) / z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[Less[z, 249.6182814532307], N[(N[(y * N[(x / z), $MachinePrecision]), $MachinePrecision] / N[(z + N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(y / z), $MachinePrecision] / N[(1.0 + z), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] / z), $MachinePrecision]]

Reproduce

herbie shell --seed 2023301 
(FPCore (x y z)
  :name "Statistics.Distribution.Beta:$cvariance from math-functions-0.1.5.2"
  :precision binary64

  :herbie-target
  (if (< z 249.6182814532307) (/ (* y (/ x z)) (+ z (* z z))) (/ (* (/ (/ y z) (+ 1.0 z)) x) z))

  (/ (* x y) (* (* z z) (+ z 1.0))))