Numeric.SpecFunctions:invErfc from math-functions-0.1.5.2, A

Percentage Accurate: 95.5% → 99.7%

Time: 11.0s

Alternatives: 14

Speedup: 5.8×

Specification

Math

\[\begin{array}{l} \\ x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \end{array} \]

FPCore

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

C

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

Java

public static double code(double x, double y, double z) {
	return x + (y / ((1.1283791670955126 * Math.exp(z)) - (x * y)));
}

Python

def code(x, y, z):
	return x + (y / ((1.1283791670955126 * math.exp(z)) - (x * y)))

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 95.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \end{array} \]

FPCore

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

C

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

Java

public static double code(double x, double y, double z) {
	return x + (y / ((1.1283791670955126 * Math.exp(z)) - (x * y)));
}

Python

def code(x, y, z):
	return x + (y / ((1.1283791670955126 * math.exp(z)) - (x * y)))

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1.0005:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x + \left(y \cdot 0.8862269254527579\right) \cdot e^{-z}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= (exp z) 0.0)
   (+ x (/ -1.0 x))
   (if (<= (exp z) 1.0005)
     (+ x (/ y (- 1.1283791670955126 (+ (* z -1.1283791670955126) (* x y)))))
     (+ x (* (* y 0.8862269254527579) (exp (- z)))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else if (exp(z) <= 1.0005) {
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	} else {
		tmp = x + ((y * 0.8862269254527579) * exp(-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 (exp(z) <= 0.0d0) then
        tmp = x + ((-1.0d0) / x)
    else if (exp(z) <= 1.0005d0) then
        tmp = x + (y / (1.1283791670955126d0 - ((z * (-1.1283791670955126d0)) + (x * y))))
    else
        tmp = x + ((y * 0.8862269254527579d0) * exp(-z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (Math.exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else if (Math.exp(z) <= 1.0005) {
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	} else {
		tmp = x + ((y * 0.8862269254527579) * Math.exp(-z));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if math.exp(z) <= 0.0:
		tmp = x + (-1.0 / x)
	elif math.exp(z) <= 1.0005:
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))))
	else:
		tmp = x + ((y * 0.8862269254527579) * math.exp(-z))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (exp(z) <= 0.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (exp(z) <= 1.0005)
		tmp = Float64(x + Float64(y / Float64(1.1283791670955126 - Float64(Float64(z * -1.1283791670955126) + Float64(x * y)))));
	else
		tmp = Float64(x + Float64(Float64(y * 0.8862269254527579) * exp(Float64(-z))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (exp(z) <= 0.0)
		tmp = x + (-1.0 / x);
	elseif (exp(z) <= 1.0005)
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	else
		tmp = x + ((y * 0.8862269254527579) * exp(-z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[N[Exp[z], $MachinePrecision], 0.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Exp[z], $MachinePrecision], 1.0005], N[(x + N[(y / N[(1.1283791670955126 - N[(N[(z * -1.1283791670955126), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y * 0.8862269254527579), $MachinePrecision] * N[Exp[(-z)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 88.0%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if 0.0 < (exp.f64 z) < 1.00049999999999994

   1. Initial program 99.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.9%

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

      2. distribute-frac-neg 99.9%

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

      3. unsub-neg 99.9%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.9%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.9%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.9%

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

      9. +-commutative 99.9%

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

      10. fma-define 99.9%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.9%

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

   if 1.00049999999999994 < (exp.f64 z)

   1. Initial program 93.5%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 100.0%

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

      1. associate-*r/ 100.0%

         \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   5. Simplified 100.0%

      \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]
   6. Step-by-step derivation

      1. div-inv 100.0%

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

      2. *-commutative 100.0%

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

      3. rec-exp 100.0%

         \[\leadsto x + \left(y \cdot 0.8862269254527579\right) \cdot \color{blue}{e^{-z}} \]

   7. Applied egg-rr 100.0%

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

4. Final simplification 99.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1.0005:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x + \left(y \cdot 0.8862269254527579\right) \cdot e^{-z}\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 99.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1.0005:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y \cdot 0.8862269254527579}{e^{z}}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= (exp z) 0.0)
   (+ x (/ -1.0 x))
   (if (<= (exp z) 1.0005)
     (+ x (/ y (- 1.1283791670955126 (+ (* z -1.1283791670955126) (* x y)))))
     (+ x (/ (* y 0.8862269254527579) (exp z))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else if (exp(z) <= 1.0005) {
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	} else {
		tmp = x + ((y * 0.8862269254527579) / exp(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 (exp(z) <= 0.0d0) then
        tmp = x + ((-1.0d0) / x)
    else if (exp(z) <= 1.0005d0) then
        tmp = x + (y / (1.1283791670955126d0 - ((z * (-1.1283791670955126d0)) + (x * y))))
    else
        tmp = x + ((y * 0.8862269254527579d0) / exp(z))
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (Math.exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else if (Math.exp(z) <= 1.0005) {
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	} else {
		tmp = x + ((y * 0.8862269254527579) / Math.exp(z));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if math.exp(z) <= 0.0:
		tmp = x + (-1.0 / x)
	elif math.exp(z) <= 1.0005:
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))))
	else:
		tmp = x + ((y * 0.8862269254527579) / math.exp(z))
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (exp(z) <= 0.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (exp(z) <= 1.0005)
		tmp = Float64(x + Float64(y / Float64(1.1283791670955126 - Float64(Float64(z * -1.1283791670955126) + Float64(x * y)))));
	else
		tmp = Float64(x + Float64(Float64(y * 0.8862269254527579) / exp(z)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (exp(z) <= 0.0)
		tmp = x + (-1.0 / x);
	elseif (exp(z) <= 1.0005)
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	else
		tmp = x + ((y * 0.8862269254527579) / exp(z));
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[N[Exp[z], $MachinePrecision], 0.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Exp[z], $MachinePrecision], 1.0005], N[(x + N[(y / N[(1.1283791670955126 - N[(N[(z * -1.1283791670955126), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(y * 0.8862269254527579), $MachinePrecision] / N[Exp[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 88.0%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if 0.0 < (exp.f64 z) < 1.00049999999999994

   1. Initial program 99.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.9%

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

      2. distribute-frac-neg 99.9%

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

      3. unsub-neg 99.9%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.9%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.9%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.9%

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

      9. +-commutative 99.9%

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

      10. fma-define 99.9%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.9%

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

   if 1.00049999999999994 < (exp.f64 z)

   1. Initial program 93.5%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 100.0%

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

      1. associate-*r/ 100.0%

         \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   5. Simplified 100.0%

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

4. Final simplification 99.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1.0005:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y \cdot 0.8862269254527579}{e^{z}}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 99.9% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= (exp z) 0.0)
   (+ x (/ -1.0 x))
   (- x (/ y (fma x y (* (exp z) -1.1283791670955126))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else {
		tmp = x - (y / fma(x, y, (exp(z) * -1.1283791670955126)));
	}
	return tmp;
}

Julia

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

Wolfram

code[x_, y_, z_] := If[LessEqual[N[Exp[z], $MachinePrecision], 0.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], N[(x - N[(y / N[(x * y + N[(N[Exp[z], $MachinePrecision] * -1.1283791670955126), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 88.0%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if 0.0 < (exp.f64 z)

   1. Initial program 97.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 97.8%

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

      2. distribute-frac-neg 97.8%

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

      3. unsub-neg 97.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 97.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 97.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 97.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 97.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 97.8%

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

      9. +-commutative 97.8%

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

      10. fma-define 99.9%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing
3. Recombined 2 regimes into one program.

4. Final simplification 99.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 99.4% accurate, 3.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 150:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 + \left(z \cdot \left(1.1283791670955126 + z \cdot \left(0.5641895835477563 - z \cdot -0.18806319451591877\right)\right) - x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1350000000000.0)
   (+ x (/ -1.0 x))
   (if (<= z 150.0)
     (+
      x
      (/
       y
       (+
        1.1283791670955126
        (-
         (*
          z
          (+
           1.1283791670955126
           (* z (- 0.5641895835477563 (* z -0.18806319451591877)))))
         (* x y)))))
     x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 150.0) {
		tmp = x + (y / (1.1283791670955126 + ((z * (1.1283791670955126 + (z * (0.5641895835477563 - (z * -0.18806319451591877))))) - (x * y))));
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= (-1350000000000.0d0)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= 150.0d0) then
        tmp = x + (y / (1.1283791670955126d0 + ((z * (1.1283791670955126d0 + (z * (0.5641895835477563d0 - (z * (-0.18806319451591877d0)))))) - (x * y))))
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 150.0) {
		tmp = x + (y / (1.1283791670955126 + ((z * (1.1283791670955126 + (z * (0.5641895835477563 - (z * -0.18806319451591877))))) - (x * y))));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1350000000000.0:
		tmp = x + (-1.0 / x)
	elif z <= 150.0:
		tmp = x + (y / (1.1283791670955126 + ((z * (1.1283791670955126 + (z * (0.5641895835477563 - (z * -0.18806319451591877))))) - (x * y))))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 150.0)
		tmp = Float64(x + Float64(y / Float64(1.1283791670955126 + Float64(Float64(z * Float64(1.1283791670955126 + Float64(z * Float64(0.5641895835477563 - Float64(z * -0.18806319451591877))))) - Float64(x * y)))));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = x + (-1.0 / x);
	elseif (z <= 150.0)
		tmp = x + (y / (1.1283791670955126 + ((z * (1.1283791670955126 + (z * (0.5641895835477563 - (z * -0.18806319451591877))))) - (x * y))));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1350000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 150.0], N[(x + N[(y / N[(1.1283791670955126 + N[(N[(z * N[(1.1283791670955126 + N[(z * N[(0.5641895835477563 - N[(z * -0.18806319451591877), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -1.35e12

   1. Initial program 87.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < 150

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.8%

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

      2. distribute-frac-neg 99.8%

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

      3. unsub-neg 99.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.8%

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

      9. +-commutative 99.8%

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

      10. fma-define 99.8%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.5%

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

   if 150 < z

   1. Initial program 93.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 100.0%

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

4. Final simplification 99.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 150:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 + \left(z \cdot \left(1.1283791670955126 + z \cdot \left(0.5641895835477563 - z \cdot -0.18806319451591877\right)\right) - x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 86.5% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq -3.05 \cdot 10^{-211}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 10^{-12}:\\ \;\;\;\;x + 0.8862269254527579 \cdot \left(y - z \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))))
   (if (<= z -1350000000000.0)
     t_0
     (if (<= z -3.05e-211)
       (- x (/ y -1.1283791670955126))
       (if (<= z -4.5e-259)
         t_0
         (if (<= z 1e-12) (+ x (* 0.8862269254527579 (- y (* z y)))) x))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = t_0;
	} else if (z <= -3.05e-211) {
		tmp = x - (y / -1.1283791670955126);
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 1e-12) {
		tmp = x + (0.8862269254527579 * (y - (z * y)));
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = x + ((-1.0d0) / x)
    if (z <= (-1350000000000.0d0)) then
        tmp = t_0
    else if (z <= (-3.05d-211)) then
        tmp = x - (y / (-1.1283791670955126d0))
    else if (z <= (-4.5d-259)) then
        tmp = t_0
    else if (z <= 1d-12) then
        tmp = x + (0.8862269254527579d0 * (y - (z * y)))
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = t_0;
	} else if (z <= -3.05e-211) {
		tmp = x - (y / -1.1283791670955126);
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 1e-12) {
		tmp = x + (0.8862269254527579 * (y - (z * y)));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	tmp = 0
	if z <= -1350000000000.0:
		tmp = t_0
	elif z <= -3.05e-211:
		tmp = x - (y / -1.1283791670955126)
	elif z <= -4.5e-259:
		tmp = t_0
	elif z <= 1e-12:
		tmp = x + (0.8862269254527579 * (y - (z * y)))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = t_0;
	elseif (z <= -3.05e-211)
		tmp = Float64(x - Float64(y / -1.1283791670955126));
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 1e-12)
		tmp = Float64(x + Float64(0.8862269254527579 * Float64(y - Float64(z * y))));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (-1.0 / x);
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = t_0;
	elseif (z <= -3.05e-211)
		tmp = x - (y / -1.1283791670955126);
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 1e-12)
		tmp = x + (0.8862269254527579 * (y - (z * y)));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1350000000000.0], t$95$0, If[LessEqual[z, -3.05e-211], N[(x - N[(y / -1.1283791670955126), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.5e-259], t$95$0, If[LessEqual[z, 1e-12], N[(x + N[(0.8862269254527579 * N[(y - N[(z * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -1.35e12 or -3.05e-211 < z < -4.49999999999999974e-259

   1. Initial program 89.0%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < -3.05e-211

   1. Initial program 99.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.9%

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

      2. distribute-frac-neg 99.9%

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

      3. unsub-neg 99.9%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.9%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.9%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.9%

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

      9. +-commutative 99.9%

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

      10. fma-define 99.9%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.9%

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

   6. Taylor expanded in x around inf 99.9%

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

      1. *-commutative 99.9%

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

   8. Simplified 99.9%

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

   9. Taylor expanded in y around 0 85.3%

      \[\leadsto x - \frac{y}{\color{blue}{-1.1283791670955126}} \]

   if -4.49999999999999974e-259 < z < 9.9999999999999998e-13

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.8%

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

      2. distribute-frac-neg 99.8%

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

      3. unsub-neg 99.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.8%

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

      9. +-commutative 99.8%

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

      10. fma-define 99.8%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.8%

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

   6. Taylor expanded in y around 0 74.7%

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

   7. Taylor expanded in z around 0 74.7%

      \[\leadsto x - \color{blue}{\left(-0.8862269254527579 \cdot y + 0.8862269254527579 \cdot \left(y \cdot z\right)\right)} \]
   8. Step-by-step derivation

      1. +-commutative 74.7%

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

      2. metadata-eval 74.7%

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

      3. cancel-sign-sub-inv 74.7%

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

      4. distribute-lft-out-- 74.7%

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

   9. Simplified 74.7%

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

   if 9.9999999999999998e-13 < z

   1. Initial program 93.7%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 98.5%

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

4. Final simplification 89.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -3.05 \cdot 10^{-211}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 10^{-12}:\\ \;\;\;\;x + 0.8862269254527579 \cdot \left(y - z \cdot y\right)\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 99.4% accurate, 4.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 110:\\ \;\;\;\;x - \frac{y}{\left(x \cdot y + z \cdot \left(z \cdot -0.5641895835477563 - 1.1283791670955126\right)\right) - 1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1350000000000.0)
   (+ x (/ -1.0 x))
   (if (<= z 110.0)
     (-
      x
      (/
       y
       (-
        (+ (* x y) (* z (- (* z -0.5641895835477563) 1.1283791670955126)))
        1.1283791670955126)))
     x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 110.0) {
		tmp = x - (y / (((x * y) + (z * ((z * -0.5641895835477563) - 1.1283791670955126))) - 1.1283791670955126));
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

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

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 110.0) {
		tmp = x - (y / (((x * y) + (z * ((z * -0.5641895835477563) - 1.1283791670955126))) - 1.1283791670955126));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1350000000000.0:
		tmp = x + (-1.0 / x)
	elif z <= 110.0:
		tmp = x - (y / (((x * y) + (z * ((z * -0.5641895835477563) - 1.1283791670955126))) - 1.1283791670955126))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 110.0)
		tmp = Float64(x - Float64(y / Float64(Float64(Float64(x * y) + Float64(z * Float64(Float64(z * -0.5641895835477563) - 1.1283791670955126))) - 1.1283791670955126)));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = x + (-1.0 / x);
	elseif (z <= 110.0)
		tmp = x - (y / (((x * y) + (z * ((z * -0.5641895835477563) - 1.1283791670955126))) - 1.1283791670955126));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1350000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 110.0], N[(x - N[(y / N[(N[(N[(x * y), $MachinePrecision] + N[(z * N[(N[(z * -0.5641895835477563), $MachinePrecision] - 1.1283791670955126), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 1.1283791670955126), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -1.35e12

   1. Initial program 87.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < 110

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.8%

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

      2. distribute-frac-neg 99.8%

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

      3. unsub-neg 99.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.8%

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

      9. +-commutative 99.8%

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

      10. fma-define 99.8%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.4%

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

   if 110 < z

   1. Initial program 93.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 100.0%

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

4. Final simplification 99.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 110:\\ \;\;\;\;x - \frac{y}{\left(x \cdot y + z \cdot \left(z \cdot -0.5641895835477563 - 1.1283791670955126\right)\right) - 1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 86.5% accurate, 4.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ t_1 := x - \frac{y}{-1.1283791670955126}\\ \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq -7 \cdot 10^{-222}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 6.2 \cdot 10^{-13}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))) (t_1 (- x (/ y -1.1283791670955126))))
   (if (<= z -1350000000000.0)
     t_0
     (if (<= z -7e-222)
       t_1
       (if (<= z -4.5e-259) t_0 (if (<= z 6.2e-13) t_1 x))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x - (y / -1.1283791670955126);
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = t_0;
	} else if (z <= -7e-222) {
		tmp = t_1;
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 6.2e-13) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x + ((-1.0d0) / x)
    t_1 = x - (y / (-1.1283791670955126d0))
    if (z <= (-1350000000000.0d0)) then
        tmp = t_0
    else if (z <= (-7d-222)) then
        tmp = t_1
    else if (z <= (-4.5d-259)) then
        tmp = t_0
    else if (z <= 6.2d-13) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x - (y / -1.1283791670955126);
	double tmp;
	if (z <= -1350000000000.0) {
		tmp = t_0;
	} else if (z <= -7e-222) {
		tmp = t_1;
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 6.2e-13) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	t_1 = x - (y / -1.1283791670955126)
	tmp = 0
	if z <= -1350000000000.0:
		tmp = t_0
	elif z <= -7e-222:
		tmp = t_1
	elif z <= -4.5e-259:
		tmp = t_0
	elif z <= 6.2e-13:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	t_1 = Float64(x - Float64(y / -1.1283791670955126))
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = t_0;
	elseif (z <= -7e-222)
		tmp = t_1;
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 6.2e-13)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (-1.0 / x);
	t_1 = x - (y / -1.1283791670955126);
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = t_0;
	elseif (z <= -7e-222)
		tmp = t_1;
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 6.2e-13)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x - N[(y / -1.1283791670955126), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1350000000000.0], t$95$0, If[LessEqual[z, -7e-222], t$95$1, If[LessEqual[z, -4.5e-259], t$95$0, If[LessEqual[z, 6.2e-13], t$95$1, x]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -1.35e12 or -7.00000000000000049e-222 < z < -4.49999999999999974e-259

   1. Initial program 89.0%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < -7.00000000000000049e-222 or -4.49999999999999974e-259 < z < 6.1999999999999998e-13

   1. Initial program 99.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.9%

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

      2. distribute-frac-neg 99.9%

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

      3. unsub-neg 99.9%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.9%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.9%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.9%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.9%

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

      9. +-commutative 99.9%

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

      10. fma-define 99.9%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.9%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.9%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.9%

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

   6. Taylor expanded in x around inf 99.8%

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

      1. *-commutative 99.8%

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

   8. Simplified 99.8%

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

   9. Taylor expanded in y around 0 79.2%

      \[\leadsto x - \frac{y}{\color{blue}{-1.1283791670955126}} \]

   if 6.1999999999999998e-13 < z

   1. Initial program 93.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 97.1%

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

4. Final simplification 89.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -7 \cdot 10^{-222}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 6.2 \cdot 10^{-13}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 86.9% accurate, 4.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ t_1 := x + y \cdot 0.8862269254527579\\ \mathbf{if}\;z \leq -3.1 \cdot 10^{-25}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq -2 \cdot 10^{-217}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{-13}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))) (t_1 (+ x (* y 0.8862269254527579))))
   (if (<= z -3.1e-25)
     t_0
     (if (<= z -2e-217)
       t_1
       (if (<= z -4.5e-259) t_0 (if (<= z 5.5e-13) t_1 x))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x + (y * 0.8862269254527579);
	double tmp;
	if (z <= -3.1e-25) {
		tmp = t_0;
	} else if (z <= -2e-217) {
		tmp = t_1;
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 5.5e-13) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x + ((-1.0d0) / x)
    t_1 = x + (y * 0.8862269254527579d0)
    if (z <= (-3.1d-25)) then
        tmp = t_0
    else if (z <= (-2d-217)) then
        tmp = t_1
    else if (z <= (-4.5d-259)) then
        tmp = t_0
    else if (z <= 5.5d-13) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x + (y * 0.8862269254527579);
	double tmp;
	if (z <= -3.1e-25) {
		tmp = t_0;
	} else if (z <= -2e-217) {
		tmp = t_1;
	} else if (z <= -4.5e-259) {
		tmp = t_0;
	} else if (z <= 5.5e-13) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	t_1 = x + (y * 0.8862269254527579)
	tmp = 0
	if z <= -3.1e-25:
		tmp = t_0
	elif z <= -2e-217:
		tmp = t_1
	elif z <= -4.5e-259:
		tmp = t_0
	elif z <= 5.5e-13:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	t_1 = Float64(x + Float64(y * 0.8862269254527579))
	tmp = 0.0
	if (z <= -3.1e-25)
		tmp = t_0;
	elseif (z <= -2e-217)
		tmp = t_1;
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 5.5e-13)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (-1.0 / x);
	t_1 = x + (y * 0.8862269254527579);
	tmp = 0.0;
	if (z <= -3.1e-25)
		tmp = t_0;
	elseif (z <= -2e-217)
		tmp = t_1;
	elseif (z <= -4.5e-259)
		tmp = t_0;
	elseif (z <= 5.5e-13)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -3.1e-25], t$95$0, If[LessEqual[z, -2e-217], t$95$1, If[LessEqual[z, -4.5e-259], t$95$0, If[LessEqual[z, 5.5e-13], t$95$1, x]]]]]]

Derivation

1. Split input into 3 regimes

2. if z < -3.09999999999999995e-25 or -2.00000000000000016e-217 < z < -4.49999999999999974e-259

   1. Initial program 89.7%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 98.7%

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

   if -3.09999999999999995e-25 < z < -2.00000000000000016e-217 or -4.49999999999999974e-259 < z < 5.49999999999999979e-13

   1. Initial program 99.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 79.1%

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

      1. associate-*r/ 79.1%

         \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   5. Simplified 79.1%

      \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   6. Taylor expanded in z around 0 79.0%

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

      1. *-commutative 79.0%

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

   8. Simplified 79.0%

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

   if 5.49999999999999979e-13 < z

   1. Initial program 93.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 97.1%

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

4. Final simplification 89.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -3.1 \cdot 10^{-25}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -2 \cdot 10^{-217}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{elif}\;z \leq -4.5 \cdot 10^{-259}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 5.5 \cdot 10^{-13}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 9: 99.4% accurate, 4.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 126:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1350000000000.0)
   (+ x (/ -1.0 x))
   (if (<= z 126.0)
     (+ x (/ y (- 1.1283791670955126 (+ (* z -1.1283791670955126) (* x y)))))
     x)))

C

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

Fortran

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

Java

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

Python

def code(x, y, z):
	tmp = 0
	if z <= -1350000000000.0:
		tmp = x + (-1.0 / x)
	elif z <= 126.0:
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 126.0)
		tmp = Float64(x + Float64(y / Float64(1.1283791670955126 - Float64(Float64(z * -1.1283791670955126) + Float64(x * y)))));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = x + (-1.0 / x);
	elseif (z <= 126.0)
		tmp = x + (y / (1.1283791670955126 - ((z * -1.1283791670955126) + (x * y))));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1350000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 126.0], N[(x + N[(y / N[(1.1283791670955126 - N[(N[(z * -1.1283791670955126), $MachinePrecision] + N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -1.35e12

   1. Initial program 87.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < 126

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.8%

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

      2. distribute-frac-neg 99.8%

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

      3. unsub-neg 99.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.8%

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

      9. +-commutative 99.8%

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

      10. fma-define 99.8%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.4%

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

   if 126 < z

   1. Initial program 93.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 100.0%

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

4. Final simplification 99.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 126:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - \left(z \cdot -1.1283791670955126 + x \cdot y\right)}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 99.3% accurate, 5.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 165:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1350000000000.0)
   (+ x (/ -1.0 x))
   (if (<= z 165.0) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))

C

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

Fortran

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

Java

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

Python

def code(x, y, z):
	tmp = 0
	if z <= -1350000000000.0:
		tmp = x + (-1.0 / x)
	elif z <= 165.0:
		tmp = x + (y / (1.1283791670955126 - (x * y)))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1350000000000.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 165.0)
		tmp = Float64(x + Float64(y / Float64(1.1283791670955126 - Float64(x * y))));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -1350000000000.0)
		tmp = x + (-1.0 / x);
	elseif (z <= 165.0)
		tmp = x + (y / (1.1283791670955126 - (x * y)));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1350000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 165.0], N[(x + N[(y / N[(1.1283791670955126 - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -1.35e12

   1. Initial program 87.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around inf 100.0%

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

   if -1.35e12 < z < 165

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 99.8%

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

      2. distribute-frac-neg 99.8%

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

      3. unsub-neg 99.8%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 99.8%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 99.8%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 99.8%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 99.8%

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

      9. +-commutative 99.8%

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

      10. fma-define 99.8%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 99.8%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 99.8%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 99.1%

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

   if 165 < z

   1. Initial program 93.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 100.0%

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

4. Final simplification 99.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1350000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 165:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 70.5% accurate, 8.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.35 \cdot 10^{-218}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.15 \cdot 10^{-151}:\\ \;\;\;\;\frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.35e-218) x (if (<= x 1.15e-151) (/ y 1.1283791670955126) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.35e-218) {
		tmp = x;
	} else if (x <= 1.15e-151) {
		tmp = y / 1.1283791670955126;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-1.35d-218)) then
        tmp = x
    else if (x <= 1.15d-151) then
        tmp = y / 1.1283791670955126d0
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.35e-218) {
		tmp = x;
	} else if (x <= 1.15e-151) {
		tmp = y / 1.1283791670955126;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.35e-218:
		tmp = x
	elif x <= 1.15e-151:
		tmp = y / 1.1283791670955126
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.35e-218)
		tmp = x;
	elseif (x <= 1.15e-151)
		tmp = Float64(y / 1.1283791670955126);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -1.35e-218)
		tmp = x;
	elseif (x <= 1.15e-151)
		tmp = y / 1.1283791670955126;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.35e-218], x, If[LessEqual[x, 1.15e-151], N[(y / 1.1283791670955126), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -1.35e-218 or 1.14999999999999998e-151 < x

   1. Initial program 96.1%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 77.4%

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

   if -1.35e-218 < x < 1.14999999999999998e-151

   1. Initial program 92.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 92.3%

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

      2. distribute-frac-neg 92.3%

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

      3. unsub-neg 92.3%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 92.3%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 92.3%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 92.2%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 92.2%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 92.5%

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

      9. +-commutative 92.5%

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

      10. fma-define 92.5%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 92.5%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 65.5%

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

   6. Taylor expanded in y around 0 58.8%

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

   7. Taylor expanded in x around 0 51.1%

      \[\leadsto \color{blue}{-1 \cdot \frac{y}{-1.1283791670955126 \cdot z - 1.1283791670955126}} \]
   8. Step-by-step derivation

      1. mul-1-neg 51.1%

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

      2. fma-neg 51.1%

         \[\leadsto -\frac{y}{\color{blue}{\mathsf{fma}\left(-1.1283791670955126, z, -1.1283791670955126\right)}} \]

      3. metadata-eval 51.1%

         \[\leadsto -\frac{y}{\mathsf{fma}\left(-1.1283791670955126, z, \color{blue}{-1.1283791670955126}\right)} \]

      4. distribute-frac-neg2 51.1%

         \[\leadsto \color{blue}{\frac{y}{-\mathsf{fma}\left(-1.1283791670955126, z, -1.1283791670955126\right)}} \]

      5. fma-define 51.1%

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

      6. +-commutative 51.1%

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

      7. distribute-neg-in 51.1%

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

      8. metadata-eval 51.1%

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

      9. distribute-lft-neg-in 51.1%

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

      10. metadata-eval 51.1%

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

   9. Simplified 51.1%

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

   10. Taylor expanded in z around 0 49.8%

       \[\leadsto \frac{y}{\color{blue}{1.1283791670955126}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 12: 70.5% accurate, 8.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.05 \cdot 10^{-218}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.02 \cdot 10^{-150}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -2.05e-218) x (if (<= x 1.02e-150) (* y 0.8862269254527579) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -2.05e-218) {
		tmp = x;
	} else if (x <= 1.02e-150) {
		tmp = y * 0.8862269254527579;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= (-2.05d-218)) then
        tmp = x
    else if (x <= 1.02d-150) then
        tmp = y * 0.8862269254527579d0
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -2.05e-218) {
		tmp = x;
	} else if (x <= 1.02e-150) {
		tmp = y * 0.8862269254527579;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -2.05e-218:
		tmp = x
	elif x <= 1.02e-150:
		tmp = y * 0.8862269254527579
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -2.05e-218)
		tmp = x;
	elseif (x <= 1.02e-150)
		tmp = Float64(y * 0.8862269254527579);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -2.05e-218)
		tmp = x;
	elseif (x <= 1.02e-150)
		tmp = y * 0.8862269254527579;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -2.05e-218], x, If[LessEqual[x, 1.02e-150], N[(y * 0.8862269254527579), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -2.0499999999999999e-218 or 1.0199999999999999e-150 < x

   1. Initial program 96.1%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 77.4%

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

   if -2.0499999999999999e-218 < x < 1.0199999999999999e-150

   1. Initial program 92.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Step-by-step derivation

      1. remove-double-neg 92.3%

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

      2. distribute-frac-neg 92.3%

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

      3. unsub-neg 92.3%

         \[\leadsto \color{blue}{x - \frac{-y}{1.1283791670955126 \cdot e^{z} - x \cdot y}} \]

      4. distribute-frac-neg 92.3%

         \[\leadsto x - \color{blue}{\left(-\frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y}\right)} \]

      5. distribute-neg-frac2 92.3%

         \[\leadsto x - \color{blue}{\frac{y}{-\left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      6. neg-sub0 92.2%

         \[\leadsto x - \frac{y}{\color{blue}{0 - \left(1.1283791670955126 \cdot e^{z} - x \cdot y\right)}} \]

      7. associate--r- 92.2%

         \[\leadsto x - \frac{y}{\color{blue}{\left(0 - 1.1283791670955126 \cdot e^{z}\right) + x \cdot y}} \]

      8. neg-sub0 92.5%

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

      9. +-commutative 92.5%

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

      10. fma-define 92.5%

          \[\leadsto x - \frac{y}{\color{blue}{\mathsf{fma}\left(x, y, -1.1283791670955126 \cdot e^{z}\right)}} \]

      11. *-commutative 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, -\color{blue}{e^{z} \cdot 1.1283791670955126}\right)} \]

      12. distribute-rgt-neg-in 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, \color{blue}{e^{z} \cdot \left(-1.1283791670955126\right)}\right)} \]

      13. metadata-eval 92.5%

          \[\leadsto x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot \color{blue}{-1.1283791670955126}\right)} \]

   3. Simplified 92.5%

      \[\leadsto \color{blue}{x - \frac{y}{\mathsf{fma}\left(x, y, e^{z} \cdot -1.1283791670955126\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in z around 0 73.3%

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

   6. Taylor expanded in x around inf 58.6%

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

      1. *-commutative 58.6%

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

   8. Simplified 58.6%

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

   9. Taylor expanded in x around 0 49.8%

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

       1. *-commutative 49.8%

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

   11. Simplified 49.8%

       \[\leadsto \color{blue}{y \cdot 0.8862269254527579} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 71.3% accurate, 11.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq 9.2 \cdot 10^{-14}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z 9.2e-14) (+ x (* y 0.8862269254527579)) x))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= 9.2e-14) {
		tmp = x + (y * 0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (z <= 9.2d-14) then
        tmp = x + (y * 0.8862269254527579d0)
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (z <= 9.2e-14) {
		tmp = x + (y * 0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= 9.2e-14:
		tmp = x + (y * 0.8862269254527579)
	else:
		tmp = x
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < 9.19999999999999993e-14

   1. Initial program 95.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 51.4%

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

      1. associate-*r/ 51.4%

         \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   5. Simplified 51.4%

      \[\leadsto x + \color{blue}{\frac{0.8862269254527579 \cdot y}{e^{z}}} \]

   6. Taylor expanded in z around 0 65.1%

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

      1. *-commutative 65.1%

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

   8. Simplified 65.1%

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

   if 9.19999999999999993e-14 < z

   1. Initial program 93.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 97.1%

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

Alternative 14: 68.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 95.4%

   \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
2. Add Preprocessing

3. Taylor expanded in x around inf 67.2%

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

Developer target: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x + \frac{1}{\frac{1.1283791670955126}{y} \cdot e^{z} - x} \end{array} \]

FPCore

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

C

double code(double x, double y, double z) {
	return x + (1.0 / (((1.1283791670955126 / y) * exp(z)) - 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 + (1.0d0 / (((1.1283791670955126d0 / y) * exp(z)) - x))
end function

Java

public static double code(double x, double y, double z) {
	return x + (1.0 / (((1.1283791670955126 / y) * Math.exp(z)) - x));
}

Python

def code(x, y, z):
	return x + (1.0 / (((1.1283791670955126 / y) * math.exp(z)) - x))

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024086 
(FPCore (x y z)
  :name "Numeric.SpecFunctions:invErfc from math-functions-0.1.5.2, A"
  :precision binary64

  :alt
  (+ x (/ 1.0 (- (* (/ 1.1283791670955126 y) (exp z)) x)))

  (+ x (/ y (- (* 1.1283791670955126 (exp z)) (* x y)))))