Numeric.SpecFunctions:$slogFactorial from math-functions-0.1.5.2, B

Percentage Accurate: 94.1% → 98.6%

Time: 22.2s

Alternatives: 17

Speedup: 1.0×

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

Specification

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  (+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
  (/
   (+
    (* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z)
    0.083333333333333)
   x)))

C

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

Java

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

Python

def code(x, y, z):
	return ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(Float64(Float64(Float64(Float64(Float64(y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
end

Wolfram

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

Initial Program: 94.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  (+ (- (* (- x 0.5) (log x)) x) 0.91893853320467)
  (/
   (+
    (* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z)
    0.083333333333333)
   x)))

C

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

Java

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

Python

def code(x, y, z):
	return ((((x - 0.5) * math.log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x)

Julia

function code(x, y, z)
	return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) - x) + 0.91893853320467) + Float64(Float64(Float64(Float64(Float64(Float64(y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((((x - 0.5) * log(x)) - x) + 0.91893853320467) + ((((((y + 0.0007936500793651) * z) - 0.0027777777777778) * z) + 0.083333333333333) / x);
end

Wolfram

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

Alternative 1: 98.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq 4 \cdot 10^{+56}:\\ \;\;\;\;\left(x + -0.5\right) \cdot \log x + \left(0.91893853320467 - \left(x + \frac{z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right) + -0.083333333333333}{x}\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(\log x + -1\right) + z \cdot \frac{z \cdot \left(0.0007936500793651 + y\right)}{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x 4e+56)
   (+
    (* (+ x -0.5) (log x))
    (-
     0.91893853320467
     (+
      x
      (/
       (+
        (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y))))
        -0.083333333333333)
       x))))
   (+ (* x (+ (log x) -1.0)) (* z (/ (* z (+ 0.0007936500793651 y)) x)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= 4e+56) {
		tmp = ((x + -0.5) * log(x)) + (0.91893853320467 - (x + (((z * (0.0027777777777778 + (z * (-0.0007936500793651 - y)))) + -0.083333333333333) / x)));
	} else {
		tmp = (x * (log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / 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 (x <= 4d+56) then
        tmp = ((x + (-0.5d0)) * log(x)) + (0.91893853320467d0 - (x + (((z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y)))) + (-0.083333333333333d0)) / x)))
    else
        tmp = (x * (log(x) + (-1.0d0))) + (z * ((z * (0.0007936500793651d0 + y)) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= 4e+56) {
		tmp = ((x + -0.5) * Math.log(x)) + (0.91893853320467 - (x + (((z * (0.0027777777777778 + (z * (-0.0007936500793651 - y)))) + -0.083333333333333) / x)));
	} else {
		tmp = (x * (Math.log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= 4e+56:
		tmp = ((x + -0.5) * math.log(x)) + (0.91893853320467 - (x + (((z * (0.0027777777777778 + (z * (-0.0007936500793651 - y)))) + -0.083333333333333) / x)))
	else:
		tmp = (x * (math.log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= 4e+56)
		tmp = Float64(Float64(Float64(x + -0.5) * log(x)) + Float64(0.91893853320467 - Float64(x + Float64(Float64(Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y)))) + -0.083333333333333) / x))));
	else
		tmp = Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(z * Float64(Float64(z * Float64(0.0007936500793651 + y)) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= 4e+56)
		tmp = ((x + -0.5) * log(x)) + (0.91893853320467 - (x + (((z * (0.0027777777777778 + (z * (-0.0007936500793651 - y)))) + -0.083333333333333) / x)));
	else
		tmp = (x * (log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, 4e+56], N[(N[(N[(x + -0.5), $MachinePrecision] * N[Log[x], $MachinePrecision]), $MachinePrecision] + N[(0.91893853320467 - N[(x + N[(N[(N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -0.083333333333333), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(z * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < 4.00000000000000037e56

   1. Initial program 99.8%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   if 4.00000000000000037e56 < x

   1. Initial program 85.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 2: 98.1% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (/
  1.0
  (/
   1.0
   (+
    (+
     (/ 0.083333333333333 x)
     (+ (* (log x) (+ x -0.5)) (* z (* (/ z x) (+ 0.0007936500793651 y)))))
    (- 0.91893853320467 x)))))

C

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

Java

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

Python

def code(x, y, z):
	return 1.0 / (1.0 / (((0.083333333333333 / x) + ((math.log(x) * (x + -0.5)) + (z * ((z / x) * (0.0007936500793651 + y))))) + (0.91893853320467 - x)))

Julia

function code(x, y, z)
	return Float64(1.0 / Float64(1.0 / Float64(Float64(Float64(0.083333333333333 / x) + Float64(Float64(log(x) * Float64(x + -0.5)) + Float64(z * Float64(Float64(z / x) * Float64(0.0007936500793651 + y))))) + Float64(0.91893853320467 - x))))
end

MATLAB

function tmp = code(x, y, z)
	tmp = 1.0 / (1.0 / (((0.083333333333333 / x) + ((log(x) * (x + -0.5)) + (z * ((z / x) * (0.0007936500793651 + y))))) + (0.91893853320467 - x)));
end

Wolfram

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

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

6. Applied egg-rr 0

   \[\leadsto expr\]

7. Taylor expanded in z around 0 0

   \[\leadsto expr\]

9. Simplified 0

   \[\leadsto expr\]

10. Taylor expanded in z around inf 0

    \[\leadsto expr\]

12. Simplified 0

    \[\leadsto expr\]
13. Add Preprocessing

Alternative 3: 97.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\frac{0.083333333333333}{x} + \left(\log x \cdot \left(x + -0.5\right) + \left(0.91893853320467 - x\right)\right)\right) + z \cdot \left(0 - \frac{0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)}{x}\right) \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  (+ (/ 0.083333333333333 x) (+ (* (log x) (+ x -0.5)) (- 0.91893853320467 x)))
  (* z (- 0.0 (/ (+ 0.0027777777777778 (* z (- -0.0007936500793651 y))) x)))))

C

double code(double x, double y, double z) {
	return ((0.083333333333333 / x) + ((log(x) * (x + -0.5)) + (0.91893853320467 - x))) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / 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 = ((0.083333333333333d0 / x) + ((log(x) * (x + (-0.5d0))) + (0.91893853320467d0 - x))) + (z * (0.0d0 - ((0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))) / x)))
end function

Java

public static double code(double x, double y, double z) {
	return ((0.083333333333333 / x) + ((Math.log(x) * (x + -0.5)) + (0.91893853320467 - x))) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)));
}

Python

def code(x, y, z):
	return ((0.083333333333333 / x) + ((math.log(x) * (x + -0.5)) + (0.91893853320467 - x))) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)))

Julia

function code(x, y, z)
	return Float64(Float64(Float64(0.083333333333333 / x) + Float64(Float64(log(x) * Float64(x + -0.5)) + Float64(0.91893853320467 - x))) + Float64(z * Float64(0.0 - Float64(Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))) / x))))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((0.083333333333333 / x) + ((log(x) * (x + -0.5)) + (0.91893853320467 - x))) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)));
end

Wolfram

code[x_, y_, z_] := N[(N[(N[(0.083333333333333 / x), $MachinePrecision] + N[(N[(N[Log[x], $MachinePrecision] * N[(x + -0.5), $MachinePrecision]), $MachinePrecision] + N[(0.91893853320467 - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(z * N[(0.0 - N[(N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in z around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 4: 83.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq 4 \cdot 10^{+22}:\\ \;\;\;\;\frac{0.083333333333333 - z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right)}{x}\\ \mathbf{elif}\;x \leq 2.45 \cdot 10^{+107}:\\ \;\;\;\;\left(x \cdot y\right) \cdot \left(\frac{\log x}{y} + \frac{-1}{y}\right)\\ \mathbf{elif}\;x \leq 2.15 \cdot 10^{+123}:\\ \;\;\;\;\frac{z}{x} \cdot \left(z \cdot \left(0.0007936500793651 + y\right)\right)\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(-1 + \log x\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x 4e+22)
   (/
    (-
     0.083333333333333
     (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y)))))
    x)
   (if (<= x 2.45e+107)
     (* (* x y) (+ (/ (log x) y) (/ -1.0 y)))
     (if (<= x 2.15e+123)
       (* (/ z x) (* z (+ 0.0007936500793651 y)))
       (* x (+ -1.0 (log x)))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= 4e+22) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else if (x <= 2.45e+107) {
		tmp = (x * y) * ((log(x) / y) + (-1.0 / y));
	} else if (x <= 2.15e+123) {
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	} else {
		tmp = x * (-1.0 + log(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 (x <= 4d+22) then
        tmp = (0.083333333333333d0 - (z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))))) / x
    else if (x <= 2.45d+107) then
        tmp = (x * y) * ((log(x) / y) + ((-1.0d0) / y))
    else if (x <= 2.15d+123) then
        tmp = (z / x) * (z * (0.0007936500793651d0 + y))
    else
        tmp = x * ((-1.0d0) + log(x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= 4e+22) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else if (x <= 2.45e+107) {
		tmp = (x * y) * ((Math.log(x) / y) + (-1.0 / y));
	} else if (x <= 2.15e+123) {
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	} else {
		tmp = x * (-1.0 + Math.log(x));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= 4e+22:
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x
	elif x <= 2.45e+107:
		tmp = (x * y) * ((math.log(x) / y) + (-1.0 / y))
	elif x <= 2.15e+123:
		tmp = (z / x) * (z * (0.0007936500793651 + y))
	else:
		tmp = x * (-1.0 + math.log(x))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= 4e+22)
		tmp = Float64(Float64(0.083333333333333 - Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))))) / x);
	elseif (x <= 2.45e+107)
		tmp = Float64(Float64(x * y) * Float64(Float64(log(x) / y) + Float64(-1.0 / y)));
	elseif (x <= 2.15e+123)
		tmp = Float64(Float64(z / x) * Float64(z * Float64(0.0007936500793651 + y)));
	else
		tmp = Float64(x * Float64(-1.0 + log(x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= 4e+22)
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	elseif (x <= 2.45e+107)
		tmp = (x * y) * ((log(x) / y) + (-1.0 / y));
	elseif (x <= 2.15e+123)
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	else
		tmp = x * (-1.0 + log(x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, 4e+22], N[(N[(0.083333333333333 - N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 2.45e+107], N[(N[(x * y), $MachinePrecision] * N[(N[(N[Log[x], $MachinePrecision] / y), $MachinePrecision] + N[(-1.0 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 2.15e+123], N[(N[(z / x), $MachinePrecision] * N[(z * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x * N[(-1.0 + N[Log[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if x < 4e22

   1. Initial program 99.7%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 4e22 < x < 2.4500000000000001e107

   1. Initial program 93.9%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 2.4500000000000001e107 < x < 2.14999999999999993e123

   1. Initial program 58.9%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]

   if 2.14999999999999993e123 < x

   1. Initial program 86.3%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 5: 84.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \left(-1 + \log x\right)\\ \mathbf{if}\;x \leq 4.2 \cdot 10^{+23}:\\ \;\;\;\;\frac{0.083333333333333 - z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right)}{x}\\ \mathbf{elif}\;x \leq 3 \cdot 10^{+108}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 2.1 \cdot 10^{+123}:\\ \;\;\;\;\frac{z}{x} \cdot \left(z \cdot \left(0.0007936500793651 + y\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* x (+ -1.0 (log x)))))
   (if (<= x 4.2e+23)
     (/
      (-
       0.083333333333333
       (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y)))))
      x)
     (if (<= x 3e+108)
       t_0
       (if (<= x 2.1e+123) (* (/ z x) (* z (+ 0.0007936500793651 y))) t_0)))))

C

double code(double x, double y, double z) {
	double t_0 = x * (-1.0 + log(x));
	double tmp;
	if (x <= 4.2e+23) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else if (x <= 3e+108) {
		tmp = t_0;
	} else if (x <= 2.1e+123) {
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	} 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) :: tmp
    t_0 = x * ((-1.0d0) + log(x))
    if (x <= 4.2d+23) then
        tmp = (0.083333333333333d0 - (z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))))) / x
    else if (x <= 3d+108) then
        tmp = t_0
    else if (x <= 2.1d+123) then
        tmp = (z / x) * (z * (0.0007936500793651d0 + y))
    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 * (-1.0 + Math.log(x));
	double tmp;
	if (x <= 4.2e+23) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else if (x <= 3e+108) {
		tmp = t_0;
	} else if (x <= 2.1e+123) {
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x * (-1.0 + math.log(x))
	tmp = 0
	if x <= 4.2e+23:
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x
	elif x <= 3e+108:
		tmp = t_0
	elif x <= 2.1e+123:
		tmp = (z / x) * (z * (0.0007936500793651 + y))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x * Float64(-1.0 + log(x)))
	tmp = 0.0
	if (x <= 4.2e+23)
		tmp = Float64(Float64(0.083333333333333 - Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))))) / x);
	elseif (x <= 3e+108)
		tmp = t_0;
	elseif (x <= 2.1e+123)
		tmp = Float64(Float64(z / x) * Float64(z * Float64(0.0007936500793651 + y)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x * (-1.0 + log(x));
	tmp = 0.0;
	if (x <= 4.2e+23)
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	elseif (x <= 3e+108)
		tmp = t_0;
	elseif (x <= 2.1e+123)
		tmp = (z / x) * (z * (0.0007936500793651 + y));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(-1.0 + N[Log[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, 4.2e+23], N[(N[(0.083333333333333 - N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, 3e+108], t$95$0, If[LessEqual[x, 2.1e+123], N[(N[(z / x), $MachinePrecision] * N[(z * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]]

Derivation

1. Split input into 3 regimes

2. if x < 4.2000000000000003e23

   1. Initial program 99.7%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 4.2000000000000003e23 < x < 2.99999999999999984e108 or 2.09999999999999994e123 < x

   1. Initial program 88.4%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 2.99999999999999984e108 < x < 2.09999999999999994e123

   1. Initial program 58.9%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   11. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 98.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq 2.8:\\ \;\;\;\;\frac{0.083333333333333 - z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right)}{x}\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(\log x + -1\right) + z \cdot \frac{z \cdot \left(0.0007936500793651 + y\right)}{x}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x 2.8)
   (/
    (-
     0.083333333333333
     (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y)))))
    x)
   (+ (* x (+ (log x) -1.0)) (* z (/ (* z (+ 0.0007936500793651 y)) x)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= 2.8) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = (x * (log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / 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 (x <= 2.8d0) then
        tmp = (0.083333333333333d0 - (z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))))) / x
    else
        tmp = (x * (log(x) + (-1.0d0))) + (z * ((z * (0.0007936500793651d0 + y)) / x))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= 2.8) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = (x * (Math.log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= 2.8:
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x
	else:
		tmp = (x * (math.log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= 2.8)
		tmp = Float64(Float64(0.083333333333333 - Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))))) / x);
	else
		tmp = Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(z * Float64(Float64(z * Float64(0.0007936500793651 + y)) / x)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= 2.8)
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	else
		tmp = (x * (log(x) + -1.0)) + (z * ((z * (0.0007936500793651 + y)) / x));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, 2.8], N[(N[(0.083333333333333 - N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(z * N[(N[(z * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < 2.7999999999999998

   1. Initial program 99.8%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 2.7999999999999998 < x

   1. Initial program 87.5%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in z around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 93.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq 230000000000:\\ \;\;\;\;\frac{0.083333333333333 - z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right)}{x}\\ \mathbf{else}:\\ \;\;\;\;x \cdot \left(\log x + -1\right) + z \cdot \left(y \cdot \frac{z}{x}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x 230000000000.0)
   (/
    (-
     0.083333333333333
     (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y)))))
    x)
   (+ (* x (+ (log x) -1.0)) (* z (* y (/ z x))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= 230000000000.0) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = (x * (log(x) + -1.0)) + (z * (y * (z / 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 (x <= 230000000000.0d0) then
        tmp = (0.083333333333333d0 - (z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))))) / x
    else
        tmp = (x * (log(x) + (-1.0d0))) + (z * (y * (z / x)))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= 230000000000.0) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = (x * (Math.log(x) + -1.0)) + (z * (y * (z / x)));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= 230000000000.0:
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x
	else:
		tmp = (x * (math.log(x) + -1.0)) + (z * (y * (z / x)))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= 230000000000.0)
		tmp = Float64(Float64(0.083333333333333 - Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))))) / x);
	else
		tmp = Float64(Float64(x * Float64(log(x) + -1.0)) + Float64(z * Float64(y * Float64(z / x))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= 230000000000.0)
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	else
		tmp = (x * (log(x) + -1.0)) + (z * (y * (z / x)));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, 230000000000.0], N[(N[(0.083333333333333 - N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(N[(x * N[(N[Log[x], $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] + N[(z * N[(y * N[(z / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < 2.3e11

   1. Initial program 99.8%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 2.3e11 < x

   1. Initial program 86.7%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 8: 47.8% accurate, 4.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y \cdot \frac{z \cdot z}{x}\\ \mathbf{if}\;z \leq -1.9 \cdot 10^{+161}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq -5.3 \cdot 10^{+98}:\\ \;\;\;\;\frac{\left(z \cdot z\right) \cdot 0.0007936500793651}{x}\\ \mathbf{elif}\;z \leq -3800000000000:\\ \;\;\;\;\frac{y}{\frac{x}{z}} \cdot z\\ \mathbf{elif}\;z \leq 2 \cdot 10^{-35}:\\ \;\;\;\;\frac{0.083333333333333}{x}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* y (/ (* z z) x))))
   (if (<= z -1.9e+161)
     t_0
     (if (<= z -5.3e+98)
       (/ (* (* z z) 0.0007936500793651) x)
       (if (<= z -3800000000000.0)
         (* (/ y (/ x z)) z)
         (if (<= z 2e-35) (/ 0.083333333333333 x) t_0))))))

C

double code(double x, double y, double z) {
	double t_0 = y * ((z * z) / x);
	double tmp;
	if (z <= -1.9e+161) {
		tmp = t_0;
	} else if (z <= -5.3e+98) {
		tmp = ((z * z) * 0.0007936500793651) / x;
	} else if (z <= -3800000000000.0) {
		tmp = (y / (x / z)) * z;
	} else if (z <= 2e-35) {
		tmp = 0.083333333333333 / x;
	} 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) :: tmp
    t_0 = y * ((z * z) / x)
    if (z <= (-1.9d+161)) then
        tmp = t_0
    else if (z <= (-5.3d+98)) then
        tmp = ((z * z) * 0.0007936500793651d0) / x
    else if (z <= (-3800000000000.0d0)) then
        tmp = (y / (x / z)) * z
    else if (z <= 2d-35) then
        tmp = 0.083333333333333d0 / x
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = y * ((z * z) / x);
	double tmp;
	if (z <= -1.9e+161) {
		tmp = t_0;
	} else if (z <= -5.3e+98) {
		tmp = ((z * z) * 0.0007936500793651) / x;
	} else if (z <= -3800000000000.0) {
		tmp = (y / (x / z)) * z;
	} else if (z <= 2e-35) {
		tmp = 0.083333333333333 / x;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = y * ((z * z) / x)
	tmp = 0
	if z <= -1.9e+161:
		tmp = t_0
	elif z <= -5.3e+98:
		tmp = ((z * z) * 0.0007936500793651) / x
	elif z <= -3800000000000.0:
		tmp = (y / (x / z)) * z
	elif z <= 2e-35:
		tmp = 0.083333333333333 / x
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(y * Float64(Float64(z * z) / x))
	tmp = 0.0
	if (z <= -1.9e+161)
		tmp = t_0;
	elseif (z <= -5.3e+98)
		tmp = Float64(Float64(Float64(z * z) * 0.0007936500793651) / x);
	elseif (z <= -3800000000000.0)
		tmp = Float64(Float64(y / Float64(x / z)) * z);
	elseif (z <= 2e-35)
		tmp = Float64(0.083333333333333 / x);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = y * ((z * z) / x);
	tmp = 0.0;
	if (z <= -1.9e+161)
		tmp = t_0;
	elseif (z <= -5.3e+98)
		tmp = ((z * z) * 0.0007936500793651) / x;
	elseif (z <= -3800000000000.0)
		tmp = (y / (x / z)) * z;
	elseif (z <= 2e-35)
		tmp = 0.083333333333333 / x;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(y * N[(N[(z * z), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.9e+161], t$95$0, If[LessEqual[z, -5.3e+98], N[(N[(N[(z * z), $MachinePrecision] * 0.0007936500793651), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[z, -3800000000000.0], N[(N[(y / N[(x / z), $MachinePrecision]), $MachinePrecision] * z), $MachinePrecision], If[LessEqual[z, 2e-35], N[(0.083333333333333 / x), $MachinePrecision], t$95$0]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -1.9000000000000001e161 or 2.00000000000000002e-35 < z

   1. Initial program 87.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.9000000000000001e161 < z < -5.29999999999999997e98

   1. Initial program 85.6%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -5.29999999999999997e98 < z < -3.8e12

   1. Initial program 88.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]

   if -3.8e12 < z < 2.00000000000000002e-35

   1. Initial program 99.5%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 9: 60.6% accurate, 6.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := z \cdot \left(\frac{z}{x} \cdot \left(0.0007936500793651 + y\right)\right)\\ \mathbf{if}\;z \leq -5800:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 1.04 \cdot 10^{-72}:\\ \;\;\;\;\frac{0.083333333333333}{x}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* z (* (/ z x) (+ 0.0007936500793651 y)))))
   (if (<= z -5800.0) t_0 (if (<= z 1.04e-72) (/ 0.083333333333333 x) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = z * ((z / x) * (0.0007936500793651 + y));
	double tmp;
	if (z <= -5800.0) {
		tmp = t_0;
	} else if (z <= 1.04e-72) {
		tmp = 0.083333333333333 / x;
	} 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) :: tmp
    t_0 = z * ((z / x) * (0.0007936500793651d0 + y))
    if (z <= (-5800.0d0)) then
        tmp = t_0
    else if (z <= 1.04d-72) then
        tmp = 0.083333333333333d0 / x
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = z * ((z / x) * (0.0007936500793651 + y));
	double tmp;
	if (z <= -5800.0) {
		tmp = t_0;
	} else if (z <= 1.04e-72) {
		tmp = 0.083333333333333 / x;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = z * ((z / x) * (0.0007936500793651 + y))
	tmp = 0
	if z <= -5800.0:
		tmp = t_0
	elif z <= 1.04e-72:
		tmp = 0.083333333333333 / x
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(z * Float64(Float64(z / x) * Float64(0.0007936500793651 + y)))
	tmp = 0.0
	if (z <= -5800.0)
		tmp = t_0;
	elseif (z <= 1.04e-72)
		tmp = Float64(0.083333333333333 / x);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = z * ((z / x) * (0.0007936500793651 + y));
	tmp = 0.0;
	if (z <= -5800.0)
		tmp = t_0;
	elseif (z <= 1.04e-72)
		tmp = 0.083333333333333 / x;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[(N[(z / x), $MachinePrecision] * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5800.0], t$95$0, If[LessEqual[z, 1.04e-72], N[(0.083333333333333 / x), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if z < -5800 or 1.04e-72 < z

   1. Initial program 88.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -5800 < z < 1.04e-72

   1. Initial program 99.4%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 64.2% accurate, 6.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq 1.4 \cdot 10^{+52}:\\ \;\;\;\;\frac{0.083333333333333 - z \cdot \left(0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)\right)}{x}\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(\frac{z}{x} \cdot \left(0.0007936500793651 + y\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z 1.4e+52)
   (/
    (-
     0.083333333333333
     (* z (+ 0.0027777777777778 (* z (- -0.0007936500793651 y)))))
    x)
   (* z (* (/ z x) (+ 0.0007936500793651 y)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= 1.4e+52) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = z * ((z / x) * (0.0007936500793651 + 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 (z <= 1.4d+52) then
        tmp = (0.083333333333333d0 - (z * (0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))))) / x
    else
        tmp = z * ((z / x) * (0.0007936500793651d0 + y))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= 1.4e+52) {
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	} else {
		tmp = z * ((z / x) * (0.0007936500793651 + y));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= 1.4e+52:
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x
	else:
		tmp = z * ((z / x) * (0.0007936500793651 + y))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= 1.4e+52)
		tmp = Float64(Float64(0.083333333333333 - Float64(z * Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))))) / x);
	else
		tmp = Float64(z * Float64(Float64(z / x) * Float64(0.0007936500793651 + y)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= 1.4e+52)
		tmp = (0.083333333333333 - (z * (0.0027777777777778 + (z * (-0.0007936500793651 - y))))) / x;
	else
		tmp = z * ((z / x) * (0.0007936500793651 + y));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, 1.4e+52], N[(N[(0.083333333333333 - N[(z * N[(0.0027777777777778 + N[(z * N[(-0.0007936500793651 - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(z * N[(N[(z / x), $MachinePrecision] * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < 1.4e52

   1. Initial program 95.1%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 1.4e52 < z

   1. Initial program 86.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 48.4% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y \cdot \frac{z \cdot z}{x}\\ \mathbf{if}\;z \leq -3800000000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 3.6 \cdot 10^{-35}:\\ \;\;\;\;\frac{0.083333333333333}{x}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* y (/ (* z z) x))))
   (if (<= z -3800000000000.0)
     t_0
     (if (<= z 3.6e-35) (/ 0.083333333333333 x) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = y * ((z * z) / x);
	double tmp;
	if (z <= -3800000000000.0) {
		tmp = t_0;
	} else if (z <= 3.6e-35) {
		tmp = 0.083333333333333 / x;
	} 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) :: tmp
    t_0 = y * ((z * z) / x)
    if (z <= (-3800000000000.0d0)) then
        tmp = t_0
    else if (z <= 3.6d-35) then
        tmp = 0.083333333333333d0 / x
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

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

Python

def code(x, y, z):
	t_0 = y * ((z * z) / x)
	tmp = 0
	if z <= -3800000000000.0:
		tmp = t_0
	elif z <= 3.6e-35:
		tmp = 0.083333333333333 / x
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(y * Float64(Float64(z * z) / x))
	tmp = 0.0
	if (z <= -3800000000000.0)
		tmp = t_0;
	elseif (z <= 3.6e-35)
		tmp = Float64(0.083333333333333 / x);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = y * ((z * z) / x);
	tmp = 0.0;
	if (z <= -3800000000000.0)
		tmp = t_0;
	elseif (z <= 3.6e-35)
		tmp = 0.083333333333333 / x;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(y * N[(N[(z * z), $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3800000000000.0], t$95$0, If[LessEqual[z, 3.6e-35], N[(0.083333333333333 / x), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if z < -3.8e12 or 3.60000000000000019e-35 < z

   1. Initial program 87.0%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -3.8e12 < z < 3.60000000000000019e-35

   1. Initial program 99.5%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 27.2% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := y \cdot \frac{0.083333333333333}{y \cdot x}\\ \mathbf{if}\;z \leq -5 \cdot 10^{+98}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 6.2 \cdot 10^{+112}:\\ \;\;\;\;\frac{0.083333333333333}{x}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* y (/ 0.083333333333333 (* y x)))))
   (if (<= z -5e+98) t_0 (if (<= z 6.2e+112) (/ 0.083333333333333 x) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = y * (0.083333333333333 / (y * x));
	double tmp;
	if (z <= -5e+98) {
		tmp = t_0;
	} else if (z <= 6.2e+112) {
		tmp = 0.083333333333333 / x;
	} 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) :: tmp
    t_0 = y * (0.083333333333333d0 / (y * x))
    if (z <= (-5d+98)) then
        tmp = t_0
    else if (z <= 6.2d+112) then
        tmp = 0.083333333333333d0 / x
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = y * (0.083333333333333 / (y * x));
	double tmp;
	if (z <= -5e+98) {
		tmp = t_0;
	} else if (z <= 6.2e+112) {
		tmp = 0.083333333333333 / x;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = y * (0.083333333333333 / (y * x))
	tmp = 0
	if z <= -5e+98:
		tmp = t_0
	elif z <= 6.2e+112:
		tmp = 0.083333333333333 / x
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(y * Float64(0.083333333333333 / Float64(y * x)))
	tmp = 0.0
	if (z <= -5e+98)
		tmp = t_0;
	elseif (z <= 6.2e+112)
		tmp = Float64(0.083333333333333 / x);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = y * (0.083333333333333 / (y * x));
	tmp = 0.0;
	if (z <= -5e+98)
		tmp = t_0;
	elseif (z <= 6.2e+112)
		tmp = 0.083333333333333 / x;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(y * N[(0.083333333333333 / N[(y * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -5e+98], t$95$0, If[LessEqual[z, 6.2e+112], N[(0.083333333333333 / x), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if z < -4.9999999999999998e98 or 6.19999999999999965e112 < z

   1. Initial program 83.9%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in x around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -4.9999999999999998e98 < z < 6.19999999999999965e112

   1. Initial program 97.9%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 64.1% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \frac{0.083333333333333}{x} + z \cdot \left(0 - \frac{0.0027777777777778 + z \cdot \left(-0.0007936500793651 - y\right)}{x}\right) \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  (/ 0.083333333333333 x)
  (* z (- 0.0 (/ (+ 0.0027777777777778 (* z (- -0.0007936500793651 y))) x)))))

C

double code(double x, double y, double z) {
	return (0.083333333333333 / x) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / 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 = (0.083333333333333d0 / x) + (z * (0.0d0 - ((0.0027777777777778d0 + (z * ((-0.0007936500793651d0) - y))) / x)))
end function

Java

public static double code(double x, double y, double z) {
	return (0.083333333333333 / x) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)));
}

Python

def code(x, y, z):
	return (0.083333333333333 / x) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)))

Julia

function code(x, y, z)
	return Float64(Float64(0.083333333333333 / x) + Float64(z * Float64(0.0 - Float64(Float64(0.0027777777777778 + Float64(z * Float64(-0.0007936500793651 - y))) / x))))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (0.083333333333333 / x) + (z * (0.0 - ((0.0027777777777778 + (z * (-0.0007936500793651 - y))) / x)));
end

Wolfram

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

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in z around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 14: 63.7% accurate, 7.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq 14.5:\\ \;\;\;\;\frac{0.083333333333333 + \left(0.0007936500793651 + y\right) \cdot \left(z \cdot z\right)}{x}\\ \mathbf{else}:\\ \;\;\;\;z \cdot \left(\frac{z}{x} \cdot \left(0.0007936500793651 + y\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z 14.5)
   (/ (+ 0.083333333333333 (* (+ 0.0007936500793651 y) (* z z))) x)
   (* z (* (/ z x) (+ 0.0007936500793651 y)))))

C

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

Java

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

Python

def code(x, y, z):
	tmp = 0
	if z <= 14.5:
		tmp = (0.083333333333333 + ((0.0007936500793651 + y) * (z * z))) / x
	else:
		tmp = z * ((z / x) * (0.0007936500793651 + y))
	return tmp

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := If[LessEqual[z, 14.5], N[(N[(0.083333333333333 + N[(N[(0.0007936500793651 + y), $MachinePrecision] * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision], N[(z * N[(N[(z / x), $MachinePrecision] * N[(0.0007936500793651 + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if z < 14.5

   1. Initial program 94.7%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   6. Applied egg-rr 0

      \[\leadsto expr\]

   7. Taylor expanded in z around 0 0

      \[\leadsto expr\]

   9. Simplified 0

      \[\leadsto expr\]

   10. Taylor expanded in z around inf 0

       \[\leadsto expr\]

   12. Simplified 0

       \[\leadsto expr\]

   13. Taylor expanded in x around 0 0

       \[\leadsto expr\]

   15. Simplified 0

       \[\leadsto expr\]

   if 14.5 < z

   1. Initial program 89.1%

      \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

   3. Simplified 0

      \[\leadsto expr\]
   4. Add Preprocessing

   5. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   8. Taylor expanded in z around inf 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   11. Taylor expanded in y around 0 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 15: 63.7% accurate, 8.2× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  0.91893853320467
  (+ (/ 0.083333333333333 x) (* (/ (* z z) x) (+ 0.0007936500793651 y)))))

C

double code(double x, double y, double z) {
	return 0.91893853320467 + ((0.083333333333333 / x) + (((z * z) / x) * (0.0007936500793651 + 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 = 0.91893853320467d0 + ((0.083333333333333d0 / x) + (((z * z) / x) * (0.0007936500793651d0 + y)))
end function

Java

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

Python

def code(x, y, z):
	return 0.91893853320467 + ((0.083333333333333 / x) + (((z * z) / x) * (0.0007936500793651 + y)))

Julia

function code(x, y, z)
	return Float64(0.91893853320467 + Float64(Float64(0.083333333333333 / x) + Float64(Float64(Float64(z * z) / x) * Float64(0.0007936500793651 + y))))
end

MATLAB

function tmp = code(x, y, z)
	tmp = 0.91893853320467 + ((0.083333333333333 / x) + (((z * z) / x) * (0.0007936500793651 + y)));
end

Wolfram

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

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in y around inf 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in z around inf 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]

11. Taylor expanded in y around 0 0

    \[\leadsto expr\]

13. Simplified 0

    \[\leadsto expr\]
14. Add Preprocessing

Alternative 16: 23.6% accurate, 41.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := N[(0.083333333333333 / x), $MachinePrecision]

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in z around 0 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in x around 0 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]
11. Add Preprocessing

Alternative 17: 4.0% accurate, 123.0× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = 0.91893853320467d0
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := 0.91893853320467

Derivation

1. Initial program 93.2%

   \[\left(\left(\left(x - 0.5\right) \cdot \log x - x\right) + 0.91893853320467\right) + \frac{\left(\left(y + 0.0007936500793651\right) \cdot z - 0.0027777777777778\right) \cdot z + 0.083333333333333}{x} \]

3. Simplified 0

   \[\leadsto expr\]
4. Add Preprocessing

5. Taylor expanded in y around inf 0

   \[\leadsto expr\]

7. Simplified 0

   \[\leadsto expr\]

8. Taylor expanded in z around inf 0

   \[\leadsto expr\]

10. Simplified 0

    \[\leadsto expr\]

11. Taylor expanded in x around inf 0

    \[\leadsto expr\]

13. Simplified 0

    \[\leadsto expr\]
14. Add Preprocessing

Developer target: 98.7% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (+
  (+ (+ (* (- x 0.5) (log x)) (- 0.91893853320467 x)) (/ 0.083333333333333 x))
  (* (/ z x) (- (* z (+ y 0.0007936500793651)) 0.0027777777777778))))

C

double code(double x, double y, double z) {
	return ((((x - 0.5) * log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778));
}

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 - 0.5d0) * log(x)) + (0.91893853320467d0 - x)) + (0.083333333333333d0 / x)) + ((z / x) * ((z * (y + 0.0007936500793651d0)) - 0.0027777777777778d0))
end function

Java

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

Python

def code(x, y, z):
	return ((((x - 0.5) * math.log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778))

Julia

function code(x, y, z)
	return Float64(Float64(Float64(Float64(Float64(x - 0.5) * log(x)) + Float64(0.91893853320467 - x)) + Float64(0.083333333333333 / x)) + Float64(Float64(z / x) * Float64(Float64(z * Float64(y + 0.0007936500793651)) - 0.0027777777777778)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = ((((x - 0.5) * log(x)) + (0.91893853320467 - x)) + (0.083333333333333 / x)) + ((z / x) * ((z * (y + 0.0007936500793651)) - 0.0027777777777778));
end

Wolfram

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

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z)
  :name "Numeric.SpecFunctions:$slogFactorial from math-functions-0.1.5.2, B"
  :precision binary64

  :alt
  (+ (+ (+ (* (- x 0.5) (log x)) (- 0.91893853320467 x)) (/ 0.083333333333333 x)) (* (/ z x) (- (* z (+ y 0.0007936500793651)) 0.0027777777777778)))

  (+ (+ (- (* (- x 0.5) (log x)) x) 0.91893853320467) (/ (+ (* (- (* (+ y 0.0007936500793651) z) 0.0027777777777778) z) 0.083333333333333) x)))