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

Percentage Accurate: 100.0% → 100.0%

Time: 3.7s

Alternatives: 7

Speedup: 1.0×

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

Specification

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ x (/ (- y x) z)))

C

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

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 - x) / z)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ x (/ (- y x) z)))

C

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

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 - x) / z)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ x (/ (- y x) z)))

C

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

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 - x) / z)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

   \[x + \frac{y - x}{z} \]

2. Final simplification 100.0%

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

Alternative 2: 61.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{-x}{z}\\ \mathbf{if}\;z \leq -7.8 \cdot 10^{+61}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -1.5 \cdot 10^{+44}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -7200:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -1.4 \cdot 10^{-75}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -1.02 \cdot 10^{-230}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 5.4 \cdot 10^{-80}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq 3.4 \cdot 10^{-26}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{+24}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (/ (- x) z)))
   (if (<= z -7.8e+61)
     x
     (if (<= z -1.5e+44)
       (/ y z)
       (if (<= z -7200.0)
         x
         (if (<= z -1.4e-75)
           (/ y z)
           (if (<= z -1.02e-230)
             t_0
             (if (<= z 5.4e-80)
               (/ y z)
               (if (<= z 3.4e-26) t_0 (if (<= z 9.5e+24) (/ y z) x))))))))))

C

double code(double x, double y, double z) {
	double t_0 = -x / z;
	double tmp;
	if (z <= -7.8e+61) {
		tmp = x;
	} else if (z <= -1.5e+44) {
		tmp = y / z;
	} else if (z <= -7200.0) {
		tmp = x;
	} else if (z <= -1.4e-75) {
		tmp = y / z;
	} else if (z <= -1.02e-230) {
		tmp = t_0;
	} else if (z <= 5.4e-80) {
		tmp = y / z;
	} else if (z <= 3.4e-26) {
		tmp = t_0;
	} else if (z <= 9.5e+24) {
		tmp = y / z;
	} else {
		tmp = x;
	}
	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) :: t_0
    real(8) :: tmp
    t_0 = -x / z
    if (z <= (-7.8d+61)) then
        tmp = x
    else if (z <= (-1.5d+44)) then
        tmp = y / z
    else if (z <= (-7200.0d0)) then
        tmp = x
    else if (z <= (-1.4d-75)) then
        tmp = y / z
    else if (z <= (-1.02d-230)) then
        tmp = t_0
    else if (z <= 5.4d-80) then
        tmp = y / z
    else if (z <= 3.4d-26) then
        tmp = t_0
    else if (z <= 9.5d+24) then
        tmp = y / z
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = -x / z;
	double tmp;
	if (z <= -7.8e+61) {
		tmp = x;
	} else if (z <= -1.5e+44) {
		tmp = y / z;
	} else if (z <= -7200.0) {
		tmp = x;
	} else if (z <= -1.4e-75) {
		tmp = y / z;
	} else if (z <= -1.02e-230) {
		tmp = t_0;
	} else if (z <= 5.4e-80) {
		tmp = y / z;
	} else if (z <= 3.4e-26) {
		tmp = t_0;
	} else if (z <= 9.5e+24) {
		tmp = y / z;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = -x / z
	tmp = 0
	if z <= -7.8e+61:
		tmp = x
	elif z <= -1.5e+44:
		tmp = y / z
	elif z <= -7200.0:
		tmp = x
	elif z <= -1.4e-75:
		tmp = y / z
	elif z <= -1.02e-230:
		tmp = t_0
	elif z <= 5.4e-80:
		tmp = y / z
	elif z <= 3.4e-26:
		tmp = t_0
	elif z <= 9.5e+24:
		tmp = y / z
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(-x) / z)
	tmp = 0.0
	if (z <= -7.8e+61)
		tmp = x;
	elseif (z <= -1.5e+44)
		tmp = Float64(y / z);
	elseif (z <= -7200.0)
		tmp = x;
	elseif (z <= -1.4e-75)
		tmp = Float64(y / z);
	elseif (z <= -1.02e-230)
		tmp = t_0;
	elseif (z <= 5.4e-80)
		tmp = Float64(y / z);
	elseif (z <= 3.4e-26)
		tmp = t_0;
	elseif (z <= 9.5e+24)
		tmp = Float64(y / z);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = -x / z;
	tmp = 0.0;
	if (z <= -7.8e+61)
		tmp = x;
	elseif (z <= -1.5e+44)
		tmp = y / z;
	elseif (z <= -7200.0)
		tmp = x;
	elseif (z <= -1.4e-75)
		tmp = y / z;
	elseif (z <= -1.02e-230)
		tmp = t_0;
	elseif (z <= 5.4e-80)
		tmp = y / z;
	elseif (z <= 3.4e-26)
		tmp = t_0;
	elseif (z <= 9.5e+24)
		tmp = y / z;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[((-x) / z), $MachinePrecision]}, If[LessEqual[z, -7.8e+61], x, If[LessEqual[z, -1.5e+44], N[(y / z), $MachinePrecision], If[LessEqual[z, -7200.0], x, If[LessEqual[z, -1.4e-75], N[(y / z), $MachinePrecision], If[LessEqual[z, -1.02e-230], t$95$0, If[LessEqual[z, 5.4e-80], N[(y / z), $MachinePrecision], If[LessEqual[z, 3.4e-26], t$95$0, If[LessEqual[z, 9.5e+24], N[(y / z), $MachinePrecision], x]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -7.79999999999999975e61 or -1.49999999999999993e44 < z < -7200 or 9.5000000000000001e24 < z

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in z around inf 79.1%

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

   if -7.79999999999999975e61 < z < -1.49999999999999993e44 or -7200 < z < -1.39999999999999999e-75 or -1.02e-230 < z < 5.4000000000000004e-80 or 3.40000000000000013e-26 < z < 9.5000000000000001e24

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 70.3%

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

   3. Taylor expanded in x around 0 69.1%

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

   if -1.39999999999999999e-75 < z < -1.02e-230 or 5.4000000000000004e-80 < z < 3.40000000000000013e-26

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around 0 75.2%

      \[\leadsto \color{blue}{x - \frac{x}{z}} \]

   3. Taylor expanded in z around 0 75.2%

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

      1. mul-1-neg 75.2%

         \[\leadsto \color{blue}{-\frac{x}{z}} \]

      2. distribute-frac-neg 75.2%

         \[\leadsto \color{blue}{\frac{-x}{z}} \]

   5. Simplified 75.2%

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

4. Final simplification 75.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -7.8 \cdot 10^{+61}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -1.5 \cdot 10^{+44}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -7200:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -1.4 \cdot 10^{-75}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -1.02 \cdot 10^{-230}:\\ \;\;\;\;\frac{-x}{z}\\ \mathbf{elif}\;z \leq 5.4 \cdot 10^{-80}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq 3.4 \cdot 10^{-26}:\\ \;\;\;\;\frac{-x}{z}\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{+24}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 3: 75.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{y}{z}\\ t_1 := \frac{-x}{z}\\ \mathbf{if}\;z \leq -6 \cdot 10^{-79}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{-233}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 2.6 \cdot 10^{-80}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{-27}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ y z))) (t_1 (/ (- x) z)))
   (if (<= z -6e-79)
     t_0
     (if (<= z -2.1e-233)
       t_1
       (if (<= z 2.6e-80) (/ y z) (if (<= z 2.1e-27) t_1 t_0))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (y / z);
	double t_1 = -x / z;
	double tmp;
	if (z <= -6e-79) {
		tmp = t_0;
	} else if (z <= -2.1e-233) {
		tmp = t_1;
	} else if (z <= 2.6e-80) {
		tmp = y / z;
	} else if (z <= 2.1e-27) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x + (y / z)
    t_1 = -x / z
    if (z <= (-6d-79)) then
        tmp = t_0
    else if (z <= (-2.1d-233)) then
        tmp = t_1
    else if (z <= 2.6d-80) then
        tmp = y / z
    else if (z <= 2.1d-27) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (y / z);
	double t_1 = -x / z;
	double tmp;
	if (z <= -6e-79) {
		tmp = t_0;
	} else if (z <= -2.1e-233) {
		tmp = t_1;
	} else if (z <= 2.6e-80) {
		tmp = y / z;
	} else if (z <= 2.1e-27) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (y / z)
	t_1 = -x / z
	tmp = 0
	if z <= -6e-79:
		tmp = t_0
	elif z <= -2.1e-233:
		tmp = t_1
	elif z <= 2.6e-80:
		tmp = y / z
	elif z <= 2.1e-27:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(y / z))
	t_1 = Float64(Float64(-x) / z)
	tmp = 0.0
	if (z <= -6e-79)
		tmp = t_0;
	elseif (z <= -2.1e-233)
		tmp = t_1;
	elseif (z <= 2.6e-80)
		tmp = Float64(y / z);
	elseif (z <= 2.1e-27)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (y / z);
	t_1 = -x / z;
	tmp = 0.0;
	if (z <= -6e-79)
		tmp = t_0;
	elseif (z <= -2.1e-233)
		tmp = t_1;
	elseif (z <= 2.6e-80)
		tmp = y / z;
	elseif (z <= 2.1e-27)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(y / z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[((-x) / z), $MachinePrecision]}, If[LessEqual[z, -6e-79], t$95$0, If[LessEqual[z, -2.1e-233], t$95$1, If[LessEqual[z, 2.6e-80], N[(y / z), $MachinePrecision], If[LessEqual[z, 2.1e-27], t$95$1, t$95$0]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -5.99999999999999999e-79 or 2.10000000000000015e-27 < z

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 95.8%

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

   if -5.99999999999999999e-79 < z < -2.0999999999999999e-233 or 2.6000000000000001e-80 < z < 2.10000000000000015e-27

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around 0 76.3%

      \[\leadsto \color{blue}{x - \frac{x}{z}} \]

   3. Taylor expanded in z around 0 76.3%

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

      1. mul-1-neg 76.3%

         \[\leadsto \color{blue}{-\frac{x}{z}} \]

      2. distribute-frac-neg 76.3%

         \[\leadsto \color{blue}{\frac{-x}{z}} \]

   5. Simplified 76.3%

      \[\leadsto \color{blue}{\frac{-x}{z}} \]

   if -2.0999999999999999e-233 < z < 2.6000000000000001e-80

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 61.5%

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

   3. Taylor expanded in x around 0 61.7%

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

4. Final simplification 85.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6 \cdot 10^{-79}:\\ \;\;\;\;x + \frac{y}{z}\\ \mathbf{elif}\;z \leq -2.1 \cdot 10^{-233}:\\ \;\;\;\;\frac{-x}{z}\\ \mathbf{elif}\;z \leq 2.6 \cdot 10^{-80}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{-27}:\\ \;\;\;\;\frac{-x}{z}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y}{z}\\ \end{array} \]

Alternative 4: 61.6% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1 \cdot 10^{+61}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -2.8 \cdot 10^{+45}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -7200:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4 \cdot 10^{+25}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1e+61)
   x
   (if (<= z -2.8e+45)
     (/ y z)
     (if (<= z -7200.0) x (if (<= z 4e+25) (/ y z) x)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1e+61) {
		tmp = x;
	} else if (z <= -2.8e+45) {
		tmp = y / z;
	} else if (z <= -7200.0) {
		tmp = x;
	} else if (z <= 4e+25) {
		tmp = y / z;
	} else {
		tmp = x;
	}
	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 <= (-1d+61)) then
        tmp = x
    else if (z <= (-2.8d+45)) then
        tmp = y / z
    else if (z <= (-7200.0d0)) then
        tmp = x
    else if (z <= 4d+25) then
        tmp = y / z
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1e+61) {
		tmp = x;
	} else if (z <= -2.8e+45) {
		tmp = y / z;
	} else if (z <= -7200.0) {
		tmp = x;
	} else if (z <= 4e+25) {
		tmp = y / z;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1e+61:
		tmp = x
	elif z <= -2.8e+45:
		tmp = y / z
	elif z <= -7200.0:
		tmp = x
	elif z <= 4e+25:
		tmp = y / z
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1e+61)
		tmp = x;
	elseif (z <= -2.8e+45)
		tmp = Float64(y / z);
	elseif (z <= -7200.0)
		tmp = x;
	elseif (z <= 4e+25)
		tmp = Float64(y / z);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1e+61)
		tmp = x;
	elseif (z <= -2.8e+45)
		tmp = y / z;
	elseif (z <= -7200.0)
		tmp = x;
	elseif (z <= 4e+25)
		tmp = y / z;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1e+61], x, If[LessEqual[z, -2.8e+45], N[(y / z), $MachinePrecision], If[LessEqual[z, -7200.0], x, If[LessEqual[z, 4e+25], N[(y / z), $MachinePrecision], x]]]]

Derivation

1. Split input into 2 regimes

2. if z < -9.99999999999999949e60 or -2.7999999999999999e45 < z < -7200 or 4.00000000000000036e25 < z

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in z around inf 79.1%

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

   if -9.99999999999999949e60 < z < -2.7999999999999999e45 or -7200 < z < 4.00000000000000036e25

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 56.6%

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

   3. Taylor expanded in x around 0 55.5%

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

4. Final simplification 67.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1 \cdot 10^{+61}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq -2.8 \cdot 10^{+45}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{elif}\;z \leq -7200:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 4 \cdot 10^{+25}:\\ \;\;\;\;\frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 5: 86.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq -7.5 \cdot 10^{-78} \lor \neg \left(y \leq 4 \cdot 10^{-40}\right):\\ \;\;\;\;x + \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{x}{z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (or (<= y -7.5e-78) (not (<= y 4e-40))) (+ x (/ y z)) (- x (/ x z))))

C

double code(double x, double y, double z) {
	double tmp;
	if ((y <= -7.5e-78) || !(y <= 4e-40)) {
		tmp = x + (y / z);
	} else {
		tmp = x - (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 ((y <= (-7.5d-78)) .or. (.not. (y <= 4d-40))) then
        tmp = x + (y / z)
    else
        tmp = x - (x / z)
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if ((y <= -7.5e-78) || !(y <= 4e-40)) {
		tmp = x + (y / z);
	} else {
		tmp = x - (x / z);
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if (y <= -7.5e-78) or not (y <= 4e-40):
		tmp = x + (y / z)
	else:
		tmp = x - (x / z)
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if ((y <= -7.5e-78) || !(y <= 4e-40))
		tmp = Float64(x + Float64(y / z));
	else
		tmp = Float64(x - Float64(x / z));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((y <= -7.5e-78) || ~((y <= 4e-40)))
		tmp = x + (y / z);
	else
		tmp = x - (x / z);
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[Or[LessEqual[y, -7.5e-78], N[Not[LessEqual[y, 4e-40]], $MachinePrecision]], N[(x + N[(y / z), $MachinePrecision]), $MachinePrecision], N[(x - N[(x / z), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < -7.50000000000000041e-78 or 3.9999999999999997e-40 < y

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 90.1%

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

   if -7.50000000000000041e-78 < y < 3.9999999999999997e-40

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around 0 90.5%

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

4. Final simplification 90.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq -7.5 \cdot 10^{-78} \lor \neg \left(y \leq 4 \cdot 10^{-40}\right):\\ \;\;\;\;x + \frac{y}{z}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{x}{z}\\ \end{array} \]

Alternative 6: 98.0% accurate, 0.8× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (or (<= z -1.0) (not (<= z 8.5e-26))) (+ x (/ y z)) (/ (- y x) z)))

C

double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 8.5e-26)) {
		tmp = x + (y / z);
	} else {
		tmp = (y - 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 <= (-1.0d0)) .or. (.not. (z <= 8.5d-26))) then
        tmp = x + (y / z)
    else
        tmp = (y - x) / z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if ((z <= -1.0) || !(z <= 8.5e-26)) {
		tmp = x + (y / z);
	} else {
		tmp = (y - x) / z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if (z <= -1.0) or not (z <= 8.5e-26):
		tmp = x + (y / z)
	else:
		tmp = (y - x) / z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if ((z <= -1.0) || !(z <= 8.5e-26))
		tmp = Float64(x + Float64(y / z));
	else
		tmp = Float64(Float64(y - x) / z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if ((z <= -1.0) || ~((z <= 8.5e-26)))
		tmp = x + (y / z);
	else
		tmp = (y - x) / z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[Or[LessEqual[z, -1.0], N[Not[LessEqual[z, 8.5e-26]], $MachinePrecision]], N[(x + N[(y / z), $MachinePrecision]), $MachinePrecision], N[(N[(y - x), $MachinePrecision] / z), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < -1 or 8.50000000000000004e-26 < z

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around inf 99.1%

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

   if -1 < z < 8.50000000000000004e-26

   1. Initial program 100.0%

      \[x + \frac{y - x}{z} \]

   2. Taylor expanded in y around 0 93.8%

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

   3. Taylor expanded in z around 0 99.4%

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

4. Final simplification 99.2%

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

Alternative 7: 38.2% accurate, 7.0× speedup

Math

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

FPCore

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

C

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

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
end function

Java

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

Python

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

Julia

function code(x, y, z)
	return x
end

MATLAB

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

Wolfram

code[x_, y_, z_] := x

Derivation

1. Initial program 100.0%

   \[x + \frac{y - x}{z} \]

2. Taylor expanded in z around inf 40.6%

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

3. Final simplification 40.6%

   \[\leadsto x \]

Reproduce

herbie shell --seed 2023230 
(FPCore (x y z)
  :name "Statistics.Sample:$swelfordMean from math-functions-0.1.5.2"
  :precision binary64
  (+ x (/ (- y x) z)))