Numeric.SpecFunctions:stirlingError from math-functions-0.1.5.2

Percentage Accurate: 99.8% → 99.8%

Time: 13.1s

Alternatives: 12

Speedup: 1.0×

Specification

Math

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

FPCore

(FPCore (x y z) :precision binary64 (- (+ (- x (* (+ y 0.5) (log y))) y) z))

C

double code(double x, double y, double z) {
	return ((x - ((y + 0.5) * log(y))) + y) - 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 + 0.5d0) * log(y))) + y) - z
end function

Java

public static double code(double x, double y, double z) {
	return ((x - ((y + 0.5) * Math.log(y))) + y) - z;
}

Python

def code(x, y, z):
	return ((x - ((y + 0.5) * math.log(y))) + y) - z

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x - Float64(Float64(y + 0.5) * log(y))) + y) - z)
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x - ((y + 0.5) * log(y))) + y) - z;
end

Wolfram

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

Initial Program: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (- (+ (- x (* (+ y 0.5) (log y))) y) z))

C

double code(double x, double y, double z) {
	return ((x - ((y + 0.5) * log(y))) + y) - 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 + 0.5d0) * log(y))) + y) - z
end function

Java

public static double code(double x, double y, double z) {
	return ((x - ((y + 0.5) * Math.log(y))) + y) - z;
}

Python

def code(x, y, z):
	return ((x - ((y + 0.5) * math.log(y))) + y) - z

Julia

function code(x, y, z)
	return Float64(Float64(Float64(x - Float64(Float64(y + 0.5) * log(y))) + y) - z)
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((x - ((y + 0.5) * log(y))) + y) - z;
end

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (+ x (- (- y z) (* (log y) (+ y 0.5)))))

C

double code(double x, double y, double z) {
	return x + ((y - z) - (log(y) * (y + 0.5)));
}

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) - (log(y) * (y + 0.5d0)))
end function

Java

public static double code(double x, double y, double z) {
	return x + ((y - z) - (Math.log(y) * (y + 0.5)));
}

Python

def code(x, y, z):
	return x + ((y - z) - (math.log(y) * (y + 0.5)))

Julia

function code(x, y, z)
	return Float64(x + Float64(Float64(y - z) - Float64(log(y) * Float64(y + 0.5))))
end

MATLAB

function tmp = code(x, y, z)
	tmp = x + ((y - z) - (log(y) * (y + 0.5)));
end

Wolfram

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

Derivation

1. Initial program 99.9%

   \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
2. Step-by-step derivation

   1. associate--l+ 99.9%

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

   2. associate-+l- 99.9%

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

3. Simplified 99.9%

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

4. Final simplification 99.9%

   \[\leadsto x + \left(\left(y - z\right) - \log y \cdot \left(y + 0.5\right)\right) \]

Alternative 2: 76.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x - 0.5 \cdot \log y\\ t_1 := x + y \cdot \left(1 - \log y\right)\\ \mathbf{if}\;z \leq -5 \cdot 10^{+53}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{-57}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -7.6 \cdot 10^{-193}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -1.35 \cdot 10^{-231}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -2.2 \cdot 10^{-261}:\\ \;\;\;\;y - \log y \cdot \left(y + 0.5\right)\\ \mathbf{elif}\;z \leq -8 \cdot 10^{-282}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{+42}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (- x (* 0.5 (log y)))) (t_1 (+ x (* y (- 1.0 (log y))))))
   (if (<= z -5e+53)
     (- x z)
     (if (<= z -1.05e-57)
       t_1
       (if (<= z -7.6e-193)
         t_0
         (if (<= z -1.35e-231)
           t_1
           (if (<= z -2.2e-261)
             (- y (* (log y) (+ y 0.5)))
             (if (<= z -8e-282)
               t_0
               (if (<= z 7.2e+42) (+ x (- y (* y (log y)))) (- x z))))))))))

C

double code(double x, double y, double z) {
	double t_0 = x - (0.5 * log(y));
	double t_1 = x + (y * (1.0 - log(y)));
	double tmp;
	if (z <= -5e+53) {
		tmp = x - z;
	} else if (z <= -1.05e-57) {
		tmp = t_1;
	} else if (z <= -7.6e-193) {
		tmp = t_0;
	} else if (z <= -1.35e-231) {
		tmp = t_1;
	} else if (z <= -2.2e-261) {
		tmp = y - (log(y) * (y + 0.5));
	} else if (z <= -8e-282) {
		tmp = t_0;
	} else if (z <= 7.2e+42) {
		tmp = x + (y - (y * log(y)));
	} else {
		tmp = 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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x - (0.5d0 * log(y))
    t_1 = x + (y * (1.0d0 - log(y)))
    if (z <= (-5d+53)) then
        tmp = x - z
    else if (z <= (-1.05d-57)) then
        tmp = t_1
    else if (z <= (-7.6d-193)) then
        tmp = t_0
    else if (z <= (-1.35d-231)) then
        tmp = t_1
    else if (z <= (-2.2d-261)) then
        tmp = y - (log(y) * (y + 0.5d0))
    else if (z <= (-8d-282)) then
        tmp = t_0
    else if (z <= 7.2d+42) then
        tmp = x + (y - (y * log(y)))
    else
        tmp = x - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x - (0.5 * Math.log(y));
	double t_1 = x + (y * (1.0 - Math.log(y)));
	double tmp;
	if (z <= -5e+53) {
		tmp = x - z;
	} else if (z <= -1.05e-57) {
		tmp = t_1;
	} else if (z <= -7.6e-193) {
		tmp = t_0;
	} else if (z <= -1.35e-231) {
		tmp = t_1;
	} else if (z <= -2.2e-261) {
		tmp = y - (Math.log(y) * (y + 0.5));
	} else if (z <= -8e-282) {
		tmp = t_0;
	} else if (z <= 7.2e+42) {
		tmp = x + (y - (y * Math.log(y)));
	} else {
		tmp = x - z;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x - (0.5 * math.log(y))
	t_1 = x + (y * (1.0 - math.log(y)))
	tmp = 0
	if z <= -5e+53:
		tmp = x - z
	elif z <= -1.05e-57:
		tmp = t_1
	elif z <= -7.6e-193:
		tmp = t_0
	elif z <= -1.35e-231:
		tmp = t_1
	elif z <= -2.2e-261:
		tmp = y - (math.log(y) * (y + 0.5))
	elif z <= -8e-282:
		tmp = t_0
	elif z <= 7.2e+42:
		tmp = x + (y - (y * math.log(y)))
	else:
		tmp = x - z
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x - Float64(0.5 * log(y)))
	t_1 = Float64(x + Float64(y * Float64(1.0 - log(y))))
	tmp = 0.0
	if (z <= -5e+53)
		tmp = Float64(x - z);
	elseif (z <= -1.05e-57)
		tmp = t_1;
	elseif (z <= -7.6e-193)
		tmp = t_0;
	elseif (z <= -1.35e-231)
		tmp = t_1;
	elseif (z <= -2.2e-261)
		tmp = Float64(y - Float64(log(y) * Float64(y + 0.5)));
	elseif (z <= -8e-282)
		tmp = t_0;
	elseif (z <= 7.2e+42)
		tmp = Float64(x + Float64(y - Float64(y * log(y))));
	else
		tmp = Float64(x - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x - (0.5 * log(y));
	t_1 = x + (y * (1.0 - log(y)));
	tmp = 0.0;
	if (z <= -5e+53)
		tmp = x - z;
	elseif (z <= -1.05e-57)
		tmp = t_1;
	elseif (z <= -7.6e-193)
		tmp = t_0;
	elseif (z <= -1.35e-231)
		tmp = t_1;
	elseif (z <= -2.2e-261)
		tmp = y - (log(y) * (y + 0.5));
	elseif (z <= -8e-282)
		tmp = t_0;
	elseif (z <= 7.2e+42)
		tmp = x + (y - (y * log(y)));
	else
		tmp = x - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e+53], N[(x - z), $MachinePrecision], If[LessEqual[z, -1.05e-57], t$95$1, If[LessEqual[z, -7.6e-193], t$95$0, If[LessEqual[z, -1.35e-231], t$95$1, If[LessEqual[z, -2.2e-261], N[(y - N[(N[Log[y], $MachinePrecision] * N[(y + 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -8e-282], t$95$0, If[LessEqual[z, 7.2e+42], N[(x + N[(y - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - z), $MachinePrecision]]]]]]]]]]

Derivation

1. Split input into 5 regimes

2. if z < -5.0000000000000004e53 or 7.2000000000000002e42 < z

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.9%

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

      2. associate-+l- 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around inf 83.1%

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

   if -5.0000000000000004e53 < z < -1.05e-57 or -7.60000000000000007e-193 < z < -1.35000000000000011e-231

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.8%

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

      2. associate-+l- 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in y around inf 83.2%

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

      1. sub-neg 83.2%

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

      2. mul-1-neg 83.2%

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

      3. log-rec 83.2%

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

      4. remove-double-neg 83.2%

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

      5. metadata-eval 83.2%

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

   6. Simplified 83.2%

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

   if -1.05e-57 < z < -7.60000000000000007e-193 or -2.2000000000000002e-261 < z < -8.0000000000000001e-282

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 78.9%

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

   3. Taylor expanded in z around 0 78.9%

      \[\leadsto \color{blue}{x - 0.5 \cdot \log y} \]

   if -1.35000000000000011e-231 < z < -2.2000000000000002e-261

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in x around 0 99.7%

      \[\leadsto \color{blue}{\left(y - \log y \cdot \left(0.5 + y\right)\right)} - z \]

   3. Taylor expanded in z around 0 99.7%

      \[\leadsto \color{blue}{y - \log y \cdot \left(0.5 + y\right)} \]

   if -8.0000000000000001e-282 < z < 7.2000000000000002e42

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.8%

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

      2. associate-+l- 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in y around inf 80.3%

      \[\leadsto x - \left(\color{blue}{-1 \cdot \left(y \cdot \log \left(\frac{1}{y}\right)\right)} - \left(y - z\right)\right) \]
   5. Step-by-step derivation

      1. mul-1-neg 80.3%

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

      2. distribute-rgt-neg-in 80.3%

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

      3. log-rec 80.3%

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

      4. remove-double-neg 80.3%

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

   6. Simplified 80.3%

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

   7. Taylor expanded in y around inf 78.9%

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

      1. sub-neg 78.9%

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

      2. mul-1-neg 78.9%

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

      3. log-rec 78.9%

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

      4. remove-double-neg 78.9%

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

      5. metadata-eval 78.9%

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

      6. distribute-rgt-in 79.0%

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

      7. *-commutative 79.0%

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

      8. neg-mul-1 79.0%

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

      9. sub-neg 79.0%

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

   9. Simplified 79.0%

      \[\leadsto x - \color{blue}{\left(y \cdot \log y - y\right)} \]
3. Recombined 5 regimes into one program.

4. Final simplification 81.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5 \cdot 10^{+53}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -1.05 \cdot 10^{-57}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq -7.6 \cdot 10^{-193}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq -1.35 \cdot 10^{-231}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq -2.2 \cdot 10^{-261}:\\ \;\;\;\;y - \log y \cdot \left(y + 0.5\right)\\ \mathbf{elif}\;z \leq -8 \cdot 10^{-282}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 7.2 \cdot 10^{+42}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \]

Alternative 3: 67.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x - 0.5 \cdot \log y\\ t_1 := y \cdot \left(1 - \log y\right)\\ \mathbf{if}\;z \leq -8.5 \cdot 10^{+52}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -4.8 \cdot 10^{-33}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 2.55 \cdot 10^{-126}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 3.15 \cdot 10^{-84}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{-37}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 30000000000:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (- x (* 0.5 (log y)))) (t_1 (* y (- 1.0 (log y)))))
   (if (<= z -8.5e+52)
     (- x z)
     (if (<= z -4.8e-33)
       t_1
       (if (<= z 2.55e-126)
         t_0
         (if (<= z 3.15e-84)
           t_1
           (if (<= z 9.5e-37) t_0 (if (<= z 30000000000.0) t_1 (- x z)))))))))

C

double code(double x, double y, double z) {
	double t_0 = x - (0.5 * log(y));
	double t_1 = y * (1.0 - log(y));
	double tmp;
	if (z <= -8.5e+52) {
		tmp = x - z;
	} else if (z <= -4.8e-33) {
		tmp = t_1;
	} else if (z <= 2.55e-126) {
		tmp = t_0;
	} else if (z <= 3.15e-84) {
		tmp = t_1;
	} else if (z <= 9.5e-37) {
		tmp = t_0;
	} else if (z <= 30000000000.0) {
		tmp = t_1;
	} else {
		tmp = 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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x - (0.5d0 * log(y))
    t_1 = y * (1.0d0 - log(y))
    if (z <= (-8.5d+52)) then
        tmp = x - z
    else if (z <= (-4.8d-33)) then
        tmp = t_1
    else if (z <= 2.55d-126) then
        tmp = t_0
    else if (z <= 3.15d-84) then
        tmp = t_1
    else if (z <= 9.5d-37) then
        tmp = t_0
    else if (z <= 30000000000.0d0) then
        tmp = t_1
    else
        tmp = x - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x - (0.5 * Math.log(y));
	double t_1 = y * (1.0 - Math.log(y));
	double tmp;
	if (z <= -8.5e+52) {
		tmp = x - z;
	} else if (z <= -4.8e-33) {
		tmp = t_1;
	} else if (z <= 2.55e-126) {
		tmp = t_0;
	} else if (z <= 3.15e-84) {
		tmp = t_1;
	} else if (z <= 9.5e-37) {
		tmp = t_0;
	} else if (z <= 30000000000.0) {
		tmp = t_1;
	} else {
		tmp = x - z;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x - (0.5 * math.log(y))
	t_1 = y * (1.0 - math.log(y))
	tmp = 0
	if z <= -8.5e+52:
		tmp = x - z
	elif z <= -4.8e-33:
		tmp = t_1
	elif z <= 2.55e-126:
		tmp = t_0
	elif z <= 3.15e-84:
		tmp = t_1
	elif z <= 9.5e-37:
		tmp = t_0
	elif z <= 30000000000.0:
		tmp = t_1
	else:
		tmp = x - z
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x - Float64(0.5 * log(y)))
	t_1 = Float64(y * Float64(1.0 - log(y)))
	tmp = 0.0
	if (z <= -8.5e+52)
		tmp = Float64(x - z);
	elseif (z <= -4.8e-33)
		tmp = t_1;
	elseif (z <= 2.55e-126)
		tmp = t_0;
	elseif (z <= 3.15e-84)
		tmp = t_1;
	elseif (z <= 9.5e-37)
		tmp = t_0;
	elseif (z <= 30000000000.0)
		tmp = t_1;
	else
		tmp = Float64(x - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x - (0.5 * log(y));
	t_1 = y * (1.0 - log(y));
	tmp = 0.0;
	if (z <= -8.5e+52)
		tmp = x - z;
	elseif (z <= -4.8e-33)
		tmp = t_1;
	elseif (z <= 2.55e-126)
		tmp = t_0;
	elseif (z <= 3.15e-84)
		tmp = t_1;
	elseif (z <= 9.5e-37)
		tmp = t_0;
	elseif (z <= 30000000000.0)
		tmp = t_1;
	else
		tmp = x - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -8.5e+52], N[(x - z), $MachinePrecision], If[LessEqual[z, -4.8e-33], t$95$1, If[LessEqual[z, 2.55e-126], t$95$0, If[LessEqual[z, 3.15e-84], t$95$1, If[LessEqual[z, 9.5e-37], t$95$0, If[LessEqual[z, 30000000000.0], t$95$1, N[(x - z), $MachinePrecision]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -8.49999999999999994e52 or 3e10 < z

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.9%

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

      2. associate-+l- 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around inf 82.1%

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

   if -8.49999999999999994e52 < z < -4.8e-33 or 2.55000000000000001e-126 < z < 3.1500000000000002e-84 or 9.49999999999999927e-37 < z < 3e10

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.7%

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

      2. associate-+l- 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in y around inf 84.0%

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

      1. sub-neg 84.0%

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

      2. mul-1-neg 84.0%

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

      3. log-rec 84.0%

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

      4. remove-double-neg 84.0%

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

      5. metadata-eval 84.0%

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

   6. Simplified 84.0%

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

   7. Taylor expanded in x around 0 72.4%

      \[\leadsto \color{blue}{-1 \cdot \left(y \cdot \left(\log y - 1\right)\right)} \]
   8. Step-by-step derivation

      1. mul-1-neg 72.4%

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

      2. sub-neg 72.4%

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

      3. metadata-eval 72.4%

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

      4. distribute-rgt-neg-in 72.4%

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

      5. +-commutative 72.4%

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

      6. distribute-neg-in 72.4%

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

      7. metadata-eval 72.4%

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

      8. sub-neg 72.4%

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

   9. Simplified 72.4%

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

   if -4.8e-33 < z < 2.55000000000000001e-126 or 3.1500000000000002e-84 < z < 9.49999999999999927e-37

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 74.4%

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

   3. Taylor expanded in z around 0 74.4%

      \[\leadsto \color{blue}{x - 0.5 \cdot \log y} \]
3. Recombined 3 regimes into one program.

4. Final simplification 77.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{+52}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -4.8 \cdot 10^{-33}:\\ \;\;\;\;y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq 2.55 \cdot 10^{-126}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 3.15 \cdot 10^{-84}:\\ \;\;\;\;y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq 9.5 \cdot 10^{-37}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 30000000000:\\ \;\;\;\;y \cdot \left(1 - \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \]

Alternative 4: 75.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + y \cdot \left(1 - \log y\right)\\ \mathbf{if}\;z \leq -6.4 \cdot 10^{+52}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -9.8 \cdot 10^{-58}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -3.8 \cdot 10^{-284}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 1.6 \cdot 10^{+43}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (* y (- 1.0 (log y))))))
   (if (<= z -6.4e+52)
     (- x z)
     (if (<= z -9.8e-58)
       t_0
       (if (<= z -3.8e-284)
         (- x (* 0.5 (log y)))
         (if (<= z 1.6e+43) t_0 (- x z)))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (y * (1.0 - log(y)));
	double tmp;
	if (z <= -6.4e+52) {
		tmp = x - z;
	} else if (z <= -9.8e-58) {
		tmp = t_0;
	} else if (z <= -3.8e-284) {
		tmp = x - (0.5 * log(y));
	} else if (z <= 1.6e+43) {
		tmp = t_0;
	} else {
		tmp = 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) :: t_0
    real(8) :: tmp
    t_0 = x + (y * (1.0d0 - log(y)))
    if (z <= (-6.4d+52)) then
        tmp = x - z
    else if (z <= (-9.8d-58)) then
        tmp = t_0
    else if (z <= (-3.8d-284)) then
        tmp = x - (0.5d0 * log(y))
    else if (z <= 1.6d+43) then
        tmp = t_0
    else
        tmp = x - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (y * (1.0 - Math.log(y)));
	double tmp;
	if (z <= -6.4e+52) {
		tmp = x - z;
	} else if (z <= -9.8e-58) {
		tmp = t_0;
	} else if (z <= -3.8e-284) {
		tmp = x - (0.5 * Math.log(y));
	} else if (z <= 1.6e+43) {
		tmp = t_0;
	} else {
		tmp = x - z;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (y * (1.0 - math.log(y)))
	tmp = 0
	if z <= -6.4e+52:
		tmp = x - z
	elif z <= -9.8e-58:
		tmp = t_0
	elif z <= -3.8e-284:
		tmp = x - (0.5 * math.log(y))
	elif z <= 1.6e+43:
		tmp = t_0
	else:
		tmp = x - z
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(y * Float64(1.0 - log(y))))
	tmp = 0.0
	if (z <= -6.4e+52)
		tmp = Float64(x - z);
	elseif (z <= -9.8e-58)
		tmp = t_0;
	elseif (z <= -3.8e-284)
		tmp = Float64(x - Float64(0.5 * log(y)));
	elseif (z <= 1.6e+43)
		tmp = t_0;
	else
		tmp = Float64(x - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (y * (1.0 - log(y)));
	tmp = 0.0;
	if (z <= -6.4e+52)
		tmp = x - z;
	elseif (z <= -9.8e-58)
		tmp = t_0;
	elseif (z <= -3.8e-284)
		tmp = x - (0.5 * log(y));
	elseif (z <= 1.6e+43)
		tmp = t_0;
	else
		tmp = x - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -6.4e+52], N[(x - z), $MachinePrecision], If[LessEqual[z, -9.8e-58], t$95$0, If[LessEqual[z, -3.8e-284], N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.6e+43], t$95$0, N[(x - z), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -6.4e52 or 1.60000000000000007e43 < z

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.9%

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

      2. associate-+l- 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around inf 83.1%

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

   if -6.4e52 < z < -9.80000000000000061e-58 or -3.7999999999999999e-284 < z < 1.60000000000000007e43

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.8%

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

      2. associate-+l- 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in y around inf 78.8%

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

      1. sub-neg 78.8%

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

      2. mul-1-neg 78.8%

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

      3. log-rec 78.8%

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

      4. remove-double-neg 78.8%

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

      5. metadata-eval 78.8%

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

   6. Simplified 78.8%

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

   if -9.80000000000000061e-58 < z < -3.7999999999999999e-284

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 75.9%

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

   3. Taylor expanded in z around 0 75.9%

      \[\leadsto \color{blue}{x - 0.5 \cdot \log y} \]
3. Recombined 3 regimes into one program.

4. Final simplification 80.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.4 \cdot 10^{+52}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -9.8 \cdot 10^{-58}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq -3.8 \cdot 10^{-284}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 1.6 \cdot 10^{+43}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \]

Alternative 5: 75.4% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+53}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -7.2 \cdot 10^{-58}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq -1.5 \cdot 10^{-281}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 1.95 \cdot 10^{+43}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1.5e+53)
   (- x z)
   (if (<= z -7.2e-58)
     (+ x (* y (- 1.0 (log y))))
     (if (<= z -1.5e-281)
       (- x (* 0.5 (log y)))
       (if (<= z 1.95e+43) (+ x (- y (* y (log y)))) (- x z))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.5e+53) {
		tmp = x - z;
	} else if (z <= -7.2e-58) {
		tmp = x + (y * (1.0 - log(y)));
	} else if (z <= -1.5e-281) {
		tmp = x - (0.5 * log(y));
	} else if (z <= 1.95e+43) {
		tmp = x + (y - (y * log(y)));
	} else {
		tmp = 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.5d+53)) then
        tmp = x - z
    else if (z <= (-7.2d-58)) then
        tmp = x + (y * (1.0d0 - log(y)))
    else if (z <= (-1.5d-281)) then
        tmp = x - (0.5d0 * log(y))
    else if (z <= 1.95d+43) then
        tmp = x + (y - (y * log(y)))
    else
        tmp = x - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.5e+53) {
		tmp = x - z;
	} else if (z <= -7.2e-58) {
		tmp = x + (y * (1.0 - Math.log(y)));
	} else if (z <= -1.5e-281) {
		tmp = x - (0.5 * Math.log(y));
	} else if (z <= 1.95e+43) {
		tmp = x + (y - (y * Math.log(y)));
	} else {
		tmp = x - z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1.5e+53:
		tmp = x - z
	elif z <= -7.2e-58:
		tmp = x + (y * (1.0 - math.log(y)))
	elif z <= -1.5e-281:
		tmp = x - (0.5 * math.log(y))
	elif z <= 1.95e+43:
		tmp = x + (y - (y * math.log(y)))
	else:
		tmp = x - z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1.5e+53)
		tmp = Float64(x - z);
	elseif (z <= -7.2e-58)
		tmp = Float64(x + Float64(y * Float64(1.0 - log(y))));
	elseif (z <= -1.5e-281)
		tmp = Float64(x - Float64(0.5 * log(y)));
	elseif (z <= 1.95e+43)
		tmp = Float64(x + Float64(y - Float64(y * log(y))));
	else
		tmp = Float64(x - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1.5e+53)
		tmp = x - z;
	elseif (z <= -7.2e-58)
		tmp = x + (y * (1.0 - log(y)));
	elseif (z <= -1.5e-281)
		tmp = x - (0.5 * log(y));
	elseif (z <= 1.95e+43)
		tmp = x + (y - (y * log(y)));
	else
		tmp = x - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1.5e+53], N[(x - z), $MachinePrecision], If[LessEqual[z, -7.2e-58], N[(x + N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.5e-281], N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.95e+43], N[(x + N[(y - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x - z), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -1.49999999999999999e53 or 1.95e43 < z

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.9%

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

      2. associate-+l- 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around inf 83.1%

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

   if -1.49999999999999999e53 < z < -7.20000000000000019e-58

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.8%

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

      2. associate-+l- 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in y around inf 78.5%

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

      1. sub-neg 78.5%

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

      2. mul-1-neg 78.5%

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

      3. log-rec 78.5%

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

      4. remove-double-neg 78.5%

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

      5. metadata-eval 78.5%

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

   6. Simplified 78.5%

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

   if -7.20000000000000019e-58 < z < -1.49999999999999987e-281

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 75.9%

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

   3. Taylor expanded in z around 0 75.9%

      \[\leadsto \color{blue}{x - 0.5 \cdot \log y} \]

   if -1.49999999999999987e-281 < z < 1.95e43

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.8%

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

      2. associate-+l- 99.8%

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

   3. Simplified 99.8%

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

   4. Taylor expanded in y around inf 80.3%

      \[\leadsto x - \left(\color{blue}{-1 \cdot \left(y \cdot \log \left(\frac{1}{y}\right)\right)} - \left(y - z\right)\right) \]
   5. Step-by-step derivation

      1. mul-1-neg 80.3%

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

      2. distribute-rgt-neg-in 80.3%

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

      3. log-rec 80.3%

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

      4. remove-double-neg 80.3%

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

   6. Simplified 80.3%

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

   7. Taylor expanded in y around inf 78.9%

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

      1. sub-neg 78.9%

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

      2. mul-1-neg 78.9%

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

      3. log-rec 78.9%

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

      4. remove-double-neg 78.9%

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

      5. metadata-eval 78.9%

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

      6. distribute-rgt-in 79.0%

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

      7. *-commutative 79.0%

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

      8. neg-mul-1 79.0%

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

      9. sub-neg 79.0%

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

   9. Simplified 79.0%

      \[\leadsto x - \color{blue}{\left(y \cdot \log y - y\right)} \]
3. Recombined 4 regimes into one program.

4. Final simplification 80.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.5 \cdot 10^{+53}:\\ \;\;\;\;x - z\\ \mathbf{elif}\;z \leq -7.2 \cdot 10^{-58}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \mathbf{elif}\;z \leq -1.5 \cdot 10^{-281}:\\ \;\;\;\;x - 0.5 \cdot \log y\\ \mathbf{elif}\;z \leq 1.95 \cdot 10^{+43}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{else}:\\ \;\;\;\;x - z\\ \end{array} \]

Alternative 6: 87.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{if}\;y \leq 9 \cdot 10^{+42}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;y \leq 1.55 \cdot 10^{+122}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{elif}\;y \leq 6.4 \cdot 10^{+161}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (- (- x (* 0.5 (log y))) z)))
   (if (<= y 9e+42)
     t_0
     (if (<= y 1.55e+122)
       (+ x (- y (* y (log y))))
       (if (<= y 6.4e+161) t_0 (+ x (* y (- 1.0 (log y)))))))))

C

double code(double x, double y, double z) {
	double t_0 = (x - (0.5 * log(y))) - z;
	double tmp;
	if (y <= 9e+42) {
		tmp = t_0;
	} else if (y <= 1.55e+122) {
		tmp = x + (y - (y * log(y)));
	} else if (y <= 6.4e+161) {
		tmp = t_0;
	} else {
		tmp = x + (y * (1.0 - log(y)));
	}
	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 - (0.5d0 * log(y))) - z
    if (y <= 9d+42) then
        tmp = t_0
    else if (y <= 1.55d+122) then
        tmp = x + (y - (y * log(y)))
    else if (y <= 6.4d+161) then
        tmp = t_0
    else
        tmp = x + (y * (1.0d0 - log(y)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x - (0.5 * Math.log(y))) - z;
	double tmp;
	if (y <= 9e+42) {
		tmp = t_0;
	} else if (y <= 1.55e+122) {
		tmp = x + (y - (y * Math.log(y)));
	} else if (y <= 6.4e+161) {
		tmp = t_0;
	} else {
		tmp = x + (y * (1.0 - Math.log(y)));
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x - (0.5 * math.log(y))) - z
	tmp = 0
	if y <= 9e+42:
		tmp = t_0
	elif y <= 1.55e+122:
		tmp = x + (y - (y * math.log(y)))
	elif y <= 6.4e+161:
		tmp = t_0
	else:
		tmp = x + (y * (1.0 - math.log(y)))
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x - Float64(0.5 * log(y))) - z)
	tmp = 0.0
	if (y <= 9e+42)
		tmp = t_0;
	elseif (y <= 1.55e+122)
		tmp = Float64(x + Float64(y - Float64(y * log(y))));
	elseif (y <= 6.4e+161)
		tmp = t_0;
	else
		tmp = Float64(x + Float64(y * Float64(1.0 - log(y))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x - (0.5 * log(y))) - z;
	tmp = 0.0;
	if (y <= 9e+42)
		tmp = t_0;
	elseif (y <= 1.55e+122)
		tmp = x + (y - (y * log(y)));
	elseif (y <= 6.4e+161)
		tmp = t_0;
	else
		tmp = x + (y * (1.0 - log(y)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[y, 9e+42], t$95$0, If[LessEqual[y, 1.55e+122], N[(x + N[(y - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.4e+161], t$95$0, N[(x + N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if y < 9.00000000000000025e42 or 1.54999999999999999e122 < y < 6.40000000000000004e161

   1. Initial program 100.0%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 94.9%

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

   if 9.00000000000000025e42 < y < 1.54999999999999999e122

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.7%

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

      2. associate-+l- 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in y around inf 99.7%

      \[\leadsto x - \left(\color{blue}{-1 \cdot \left(y \cdot \log \left(\frac{1}{y}\right)\right)} - \left(y - z\right)\right) \]
   5. Step-by-step derivation

      1. mul-1-neg 99.7%

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

      2. distribute-rgt-neg-in 99.7%

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

      3. log-rec 99.7%

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

      4. remove-double-neg 99.7%

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

   6. Simplified 99.7%

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

   7. Taylor expanded in y around inf 74.4%

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

      1. sub-neg 74.4%

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

      2. mul-1-neg 74.4%

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

      3. log-rec 74.4%

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

      4. remove-double-neg 74.4%

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

      5. metadata-eval 74.4%

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

      6. distribute-rgt-in 74.5%

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

      7. *-commutative 74.5%

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

      8. neg-mul-1 74.5%

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

      9. sub-neg 74.5%

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

   9. Simplified 74.5%

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

   if 6.40000000000000004e161 < y

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.7%

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

      2. associate-+l- 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in y around inf 83.8%

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

      1. sub-neg 83.8%

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

      2. mul-1-neg 83.8%

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

      3. log-rec 83.8%

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

      4. remove-double-neg 83.8%

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

      5. metadata-eval 83.8%

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

   6. Simplified 83.8%

      \[\leadsto x - \color{blue}{y \cdot \left(\log y + -1\right)} \]
3. Recombined 3 regimes into one program.

4. Final simplification 89.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 9 \cdot 10^{+42}:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{elif}\;y \leq 1.55 \cdot 10^{+122}:\\ \;\;\;\;x + \left(y - y \cdot \log y\right)\\ \mathbf{elif}\;y \leq 6.4 \cdot 10^{+161}:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{else}:\\ \;\;\;\;x + y \cdot \left(1 - \log y\right)\\ \end{array} \]

Alternative 7: 99.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 0.28:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{else}:\\ \;\;\;\;x + \left(\left(y - z\right) - y \cdot \log y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= y 0.28) (- (- x (* 0.5 (log y))) z) (+ x (- (- y z) (* y (log y))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (y <= 0.28) {
		tmp = (x - (0.5 * log(y))) - z;
	} else {
		tmp = x + ((y - z) - (y * log(y)));
	}
	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 <= 0.28d0) then
        tmp = (x - (0.5d0 * log(y))) - z
    else
        tmp = x + ((y - z) - (y * log(y)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 0.28) {
		tmp = (x - (0.5 * Math.log(y))) - z;
	} else {
		tmp = x + ((y - z) - (y * Math.log(y)));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if y <= 0.28:
		tmp = (x - (0.5 * math.log(y))) - z
	else:
		tmp = x + ((y - z) - (y * math.log(y)))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (y <= 0.28)
		tmp = Float64(Float64(x - Float64(0.5 * log(y))) - z);
	else
		tmp = Float64(x + Float64(Float64(y - z) - Float64(y * log(y))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 0.28)
		tmp = (x - (0.5 * log(y))) - z;
	else
		tmp = x + ((y - z) - (y * log(y)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[y, 0.28], N[(N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(x + N[(N[(y - z), $MachinePrecision] - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 0.28000000000000003

   1. Initial program 100.0%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 99.1%

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

   if 0.28000000000000003 < y

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.7%

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

      2. associate-+l- 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in y around inf 98.5%

      \[\leadsto x - \left(\color{blue}{-1 \cdot \left(y \cdot \log \left(\frac{1}{y}\right)\right)} - \left(y - z\right)\right) \]
   5. Step-by-step derivation

      1. mul-1-neg 98.5%

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

      2. distribute-rgt-neg-in 98.5%

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

      3. log-rec 98.5%

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

      4. remove-double-neg 98.5%

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

   6. Simplified 98.5%

      \[\leadsto x - \left(\color{blue}{y \cdot \log y} - \left(y - z\right)\right) \]
3. Recombined 2 regimes into one program.

4. Final simplification 98.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 0.28:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{else}:\\ \;\;\;\;x + \left(\left(y - z\right) - y \cdot \log y\right)\\ \end{array} \]

Alternative 8: 89.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 9.2 \cdot 10^{+63}:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{else}:\\ \;\;\;\;\left(y - y \cdot \log y\right) - z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= y 9.2e+63) (- (- x (* 0.5 (log y))) z) (- (- y (* y (log y))) z)))

C

double code(double x, double y, double z) {
	double tmp;
	if (y <= 9.2e+63) {
		tmp = (x - (0.5 * log(y))) - z;
	} else {
		tmp = (y - (y * log(y))) - 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 <= 9.2d+63) then
        tmp = (x - (0.5d0 * log(y))) - z
    else
        tmp = (y - (y * log(y))) - z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 9.2e+63) {
		tmp = (x - (0.5 * Math.log(y))) - z;
	} else {
		tmp = (y - (y * Math.log(y))) - z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if y <= 9.2e+63:
		tmp = (x - (0.5 * math.log(y))) - z
	else:
		tmp = (y - (y * math.log(y))) - z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (y <= 9.2e+63)
		tmp = Float64(Float64(x - Float64(0.5 * log(y))) - z);
	else
		tmp = Float64(Float64(y - Float64(y * log(y))) - z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 9.2e+63)
		tmp = (x - (0.5 * log(y))) - z;
	else
		tmp = (y - (y * log(y))) - z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[y, 9.2e+63], N[(N[(x - N[(0.5 * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], N[(N[(y - N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 9.19999999999999973e63

   1. Initial program 100.0%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 96.0%

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

   if 9.19999999999999973e63 < y

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. add-cube-cbrt 98.4%

         \[\leadsto \color{blue}{\left(\sqrt[3]{\left(x - \left(y + 0.5\right) \cdot \log y\right) + y} \cdot \sqrt[3]{\left(x - \left(y + 0.5\right) \cdot \log y\right) + y}\right) \cdot \sqrt[3]{\left(x - \left(y + 0.5\right) \cdot \log y\right) + y}} - z \]

      2. pow3 98.4%

         \[\leadsto \color{blue}{{\left(\sqrt[3]{\left(x - \left(y + 0.5\right) \cdot \log y\right) + y}\right)}^{3}} - z \]

      3. sub-neg 98.4%

         \[\leadsto {\left(\sqrt[3]{\color{blue}{\left(x + \left(-\left(y + 0.5\right) \cdot \log y\right)\right)} + y}\right)}^{3} - z \]

      4. associate-+l+ 98.4%

         \[\leadsto {\left(\sqrt[3]{\color{blue}{x + \left(\left(-\left(y + 0.5\right) \cdot \log y\right) + y\right)}}\right)}^{3} - z \]

      5. *-commutative 98.4%

         \[\leadsto {\left(\sqrt[3]{x + \left(\left(-\color{blue}{\log y \cdot \left(y + 0.5\right)}\right) + y\right)}\right)}^{3} - z \]

      6. distribute-rgt-neg-in 98.4%

         \[\leadsto {\left(\sqrt[3]{x + \left(\color{blue}{\log y \cdot \left(-\left(y + 0.5\right)\right)} + y\right)}\right)}^{3} - z \]

      7. +-commutative 98.4%

         \[\leadsto {\left(\sqrt[3]{x + \left(\log y \cdot \left(-\color{blue}{\left(0.5 + y\right)}\right) + y\right)}\right)}^{3} - z \]

      8. distribute-neg-in 98.4%

         \[\leadsto {\left(\sqrt[3]{x + \left(\log y \cdot \color{blue}{\left(\left(-0.5\right) + \left(-y\right)\right)} + y\right)}\right)}^{3} - z \]

      9. metadata-eval 98.4%

         \[\leadsto {\left(\sqrt[3]{x + \left(\log y \cdot \left(\color{blue}{-0.5} + \left(-y\right)\right) + y\right)}\right)}^{3} - z \]

      10. sub-neg 98.4%

          \[\leadsto {\left(\sqrt[3]{x + \left(\log y \cdot \color{blue}{\left(-0.5 - y\right)} + y\right)}\right)}^{3} - z \]

   3. Applied egg-rr 98.4%

      \[\leadsto \color{blue}{{\left(\sqrt[3]{x + \left(\log y \cdot \left(-0.5 - y\right) + y\right)}\right)}^{3}} - z \]

   4. Taylor expanded in y around inf 98.4%

      \[\leadsto {\left(\sqrt[3]{x + \color{blue}{y \cdot \left(1 + \log \left(\frac{1}{y}\right)\right)}}\right)}^{3} - z \]
   5. Step-by-step derivation

      1. log-rec 98.4%

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

      2. unsub-neg 98.4%

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

   6. Simplified 98.4%

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

   7. Taylor expanded in x around 0 82.6%

      \[\leadsto \color{blue}{{1}^{0.3333333333333333} \cdot \left(y \cdot \left(1 - \log y\right)\right)} - z \]
   8. Step-by-step derivation

      1. pow-base-1 82.6%

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

      2. *-lft-identity 82.6%

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

      3. distribute-lft-out-- 82.6%

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

      4. *-rgt-identity 82.6%

         \[\leadsto \left(\color{blue}{y} - y \cdot \log y\right) - z \]

   9. Simplified 82.6%

      \[\leadsto \color{blue}{\left(y - y \cdot \log y\right)} - z \]
3. Recombined 2 regimes into one program.

4. Final simplification 90.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 9.2 \cdot 10^{+63}:\\ \;\;\;\;\left(x - 0.5 \cdot \log y\right) - z\\ \mathbf{else}:\\ \;\;\;\;\left(y - y \cdot \log y\right) - z\\ \end{array} \]

Alternative 9: 71.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;y \leq 3.4 \cdot 10^{+166}:\\ \;\;\;\;x - z\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(1 - \log y\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= y 3.4e+166) (- x z) (* y (- 1.0 (log y)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (y <= 3.4e+166) {
		tmp = x - z;
	} else {
		tmp = y * (1.0 - log(y));
	}
	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 <= 3.4d+166) then
        tmp = x - z
    else
        tmp = y * (1.0d0 - log(y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (y <= 3.4e+166) {
		tmp = x - z;
	} else {
		tmp = y * (1.0 - Math.log(y));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if y <= 3.4e+166:
		tmp = x - z
	else:
		tmp = y * (1.0 - math.log(y))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (y <= 3.4e+166)
		tmp = Float64(x - z);
	else
		tmp = Float64(y * Float64(1.0 - log(y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (y <= 3.4e+166)
		tmp = x - z;
	else
		tmp = y * (1.0 - log(y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[y, 3.4e+166], N[(x - z), $MachinePrecision], N[(y * N[(1.0 - N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if y < 3.4e166

   1. Initial program 99.9%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.9%

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

      2. associate-+l- 99.9%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around inf 68.9%

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

   if 3.4e166 < y

   1. Initial program 99.7%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
   2. Step-by-step derivation

      1. associate--l+ 99.7%

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

      2. associate-+l- 99.7%

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

   3. Simplified 99.7%

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

   4. Taylor expanded in y around inf 84.5%

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

      1. sub-neg 84.5%

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

      2. mul-1-neg 84.5%

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

      3. log-rec 84.5%

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

      4. remove-double-neg 84.5%

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

      5. metadata-eval 84.5%

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

   6. Simplified 84.5%

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

   7. Taylor expanded in x around 0 75.6%

      \[\leadsto \color{blue}{-1 \cdot \left(y \cdot \left(\log y - 1\right)\right)} \]
   8. Step-by-step derivation

      1. mul-1-neg 75.6%

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

      2. sub-neg 75.6%

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

      3. metadata-eval 75.6%

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

      4. distribute-rgt-neg-in 75.6%

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

      5. +-commutative 75.6%

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

      6. distribute-neg-in 75.6%

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

      7. metadata-eval 75.6%

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

      8. sub-neg 75.6%

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

   9. Simplified 75.6%

      \[\leadsto \color{blue}{y \cdot \left(1 - \log y\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 70.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;y \leq 3.4 \cdot 10^{+166}:\\ \;\;\;\;x - z\\ \mathbf{else}:\\ \;\;\;\;y \cdot \left(1 - \log y\right)\\ \end{array} \]

Alternative 10: 47.1% accurate, 18.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -5.6 \cdot 10^{+21}:\\ \;\;\;\;-z\\ \mathbf{elif}\;z \leq 6.8 \cdot 10^{+140}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;-z\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -5.6e+21) (- z) (if (<= z 6.8e+140) x (- z))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -5.6e+21) {
		tmp = -z;
	} else if (z <= 6.8e+140) {
		tmp = x;
	} else {
		tmp = -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 <= (-5.6d+21)) then
        tmp = -z
    else if (z <= 6.8d+140) then
        tmp = x
    else
        tmp = -z
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -5.6e+21) {
		tmp = -z;
	} else if (z <= 6.8e+140) {
		tmp = x;
	} else {
		tmp = -z;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -5.6e+21:
		tmp = -z
	elif z <= 6.8e+140:
		tmp = x
	else:
		tmp = -z
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -5.6e+21)
		tmp = Float64(-z);
	elseif (z <= 6.8e+140)
		tmp = x;
	else
		tmp = Float64(-z);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -5.6e+21)
		tmp = -z;
	elseif (z <= 6.8e+140)
		tmp = x;
	else
		tmp = -z;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -5.6e+21], (-z), If[LessEqual[z, 6.8e+140], x, (-z)]]

Derivation

1. Split input into 2 regimes

2. if z < -5.6e21 or 6.8e140 < z

   1. Initial program 100.0%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 81.9%

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

   3. Taylor expanded in z around inf 72.8%

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

      1. neg-mul-1 72.8%

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

   5. Simplified 72.8%

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

   if -5.6e21 < z < 6.8e140

   1. Initial program 99.8%

      \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

   2. Taylor expanded in y around 0 66.1%

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

   3. Taylor expanded in x around inf 38.4%

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

4. Final simplification 51.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -5.6 \cdot 10^{+21}:\\ \;\;\;\;-z\\ \mathbf{elif}\;z \leq 6.8 \cdot 10^{+140}:\\ \;\;\;\;x\\ \mathbf{else}:\\ \;\;\;\;-z\\ \end{array} \]

Alternative 11: 58.1% accurate, 37.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	return 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 - z
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.9%

   \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]
2. Step-by-step derivation

   1. associate--l+ 99.9%

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

   2. associate-+l- 99.9%

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

3. Simplified 99.9%

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

4. Taylor expanded in z around inf 58.5%

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

5. Final simplification 58.5%

   \[\leadsto x - z \]

Alternative 12: 29.3% accurate, 111.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 99.9%

   \[\left(\left(x - \left(y + 0.5\right) \cdot \log y\right) + y\right) - z \]

2. Taylor expanded in y around 0 71.9%

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

3. Taylor expanded in x around inf 27.9%

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

4. Final simplification 27.9%

   \[\leadsto x \]

Developer target: 99.8% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z) :precision binary64 (- (- (+ y x) z) (* (+ y 0.5) (log y))))

C

double code(double x, double y, double z) {
	return ((y + x) - z) - ((y + 0.5) * log(y));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = ((y + x) - z) - ((y + 0.5d0) * log(y))
end function

Java

public static double code(double x, double y, double z) {
	return ((y + x) - z) - ((y + 0.5) * Math.log(y));
}

Python

def code(x, y, z):
	return ((y + x) - z) - ((y + 0.5) * math.log(y))

Julia

function code(x, y, z)
	return Float64(Float64(Float64(y + x) - z) - Float64(Float64(y + 0.5) * log(y)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((y + x) - z) - ((y + 0.5) * log(y));
end

Wolfram

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

Reproduce

herbie shell --seed 2023275 
(FPCore (x y z)
  :name "Numeric.SpecFunctions:stirlingError from math-functions-0.1.5.2"
  :precision binary64

  :herbie-target
  (- (- (+ y x) z) (* (+ y 0.5) (log y)))

  (- (+ (- x (* (+ y 0.5) (log y))) y) z))