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

Percentage Accurate: 95.4% → 99.1%

Time: 10.2s

Alternatives: 11

Speedup: 8.5×

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.4% 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.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1.0000000000000004:\\ \;\;\;\;x + \frac{-1}{x + \frac{-1.1283791670955126}{y}}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

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

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.0000000000000004) {
		tmp = x + (-1.0 / (x + (-1.1283791670955126 / 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 (exp(z) <= 0.0d0) then
        tmp = x + ((-1.0d0) / x)
    else if (exp(z) <= 1.0000000000000004d0) then
        tmp = x + ((-1.0d0) / (x + ((-1.1283791670955126d0) / y)))
    else
        tmp = x
    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.0000000000000004) {
		tmp = x + (-1.0 / (x + (-1.1283791670955126 / y)));
	} else {
		tmp = x;
	}
	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.0000000000000004:
		tmp = x + (-1.0 / (x + (-1.1283791670955126 / y)))
	else:
		tmp = x
	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.0000000000000004)
		tmp = Float64(x + Float64(-1.0 / Float64(x + Float64(-1.1283791670955126 / y))));
	else
		tmp = x;
	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.0000000000000004)
		tmp = x + (-1.0 / (x + (-1.1283791670955126 / y)));
	else
		tmp = x;
	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.0000000000000004], N[(x + N[(-1.0 / N[(x + N[(-1.1283791670955126 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 91.1%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if 0.0 < (exp.f64 z) < 1.0000000000000004

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.9%

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

   5. Taylor expanded in z around 0 99.8%

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

      1. cancel-sign-sub-inv 99.8%

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

      2. metadata-eval 99.8%

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

      3. associate-*r/ 99.9%

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

      4. metadata-eval 99.9%

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

   7. Simplified 99.9%

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

   if 1.0000000000000004 < (exp.f64 z)

   1. Initial program 95.2%

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

      1. +-commutative 95.2%

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

      2. div-inv 95.2%

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

      3. fma-def 95.2%

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

      4. *-commutative 95.2%

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

      5. *-commutative 95.2%

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

   4. Applied egg-rr 95.2%

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

   5. Taylor expanded in y around 0 100.0%

      \[\leadsto \color{blue}{x} \]
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.0000000000000004:\\ \;\;\;\;x + \frac{-1}{x + \frac{-1.1283791670955126}{y}}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 2: 99.9% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ x + \frac{-1}{\mathsf{fma}\left(e^{z}, \frac{-1.1283791670955126}{y}, x\right)} \end{array} \]

FPCore

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

C

double code(double x, double y, double z) {
	return x + (-1.0 / fma(exp(z), (-1.1283791670955126 / y), x));
}

Julia

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

Wolfram

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

Derivation

1. Initial program 96.8%

   \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

3. Simplified 99.9%

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

5. Final simplification 99.9%

   \[\leadsto x + \frac{-1}{\mathsf{fma}\left(e^{z}, \frac{-1.1283791670955126}{y}, x\right)} \]
6. Add Preprocessing

Alternative 3: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.8%

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

   1. *-lft-identity 96.8%

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

   2. associate-/l* 96.9%

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

   3. div-sub 96.9%

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

   4. associate-*r/ 96.8%

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

   5. /-rgt-identity 96.8%

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

   6. metadata-eval 96.8%

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

   7. associate-/l* 96.8%

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

   8. *-commutative 96.8%

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

   9. neg-mul-1 96.8%

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

   10. associate-/l* 96.8%

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

   11. associate-*r* 96.8%

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

   12. *-commutative 96.8%

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

   13. neg-mul-1 96.8%

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

   14. associate-/l* 99.9%

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

   15. *-inverses 99.9%

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

   16. /-rgt-identity 99.9%

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

3. Simplified 99.9%

   \[\leadsto \color{blue}{x + \frac{1}{1.1283791670955126 \cdot \frac{e^{z}}{y} - x}} \]
4. Add Preprocessing

5. Final simplification 99.9%

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

Alternative 4: 85.7% accurate, 7.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -6.4 \cdot 10^{-6}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -1.3 \cdot 10^{-175}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq -1.55 \cdot 10^{-303}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 3.9 \cdot 10^{-16}:\\ \;\;\;\;x + \frac{-1}{\frac{-1.1283791670955126}{y}}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -6.4e-6)
   (+ x (/ -1.0 x))
   (if (<= z -1.3e-175)
     (- x (* y -0.8862269254527579))
     (if (<= z -1.55e-303)
       x
       (if (<= z 3.9e-16) (+ x (/ -1.0 (/ -1.1283791670955126 y))) x)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -6.4e-6) {
		tmp = x + (-1.0 / x);
	} else if (z <= -1.3e-175) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= -1.55e-303) {
		tmp = x;
	} else if (z <= 3.9e-16) {
		tmp = x + (-1.0 / (-1.1283791670955126 / 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 <= (-6.4d-6)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= (-1.3d-175)) then
        tmp = x - (y * (-0.8862269254527579d0))
    else if (z <= (-1.55d-303)) then
        tmp = x
    else if (z <= 3.9d-16) then
        tmp = x + ((-1.0d0) / ((-1.1283791670955126d0) / 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 <= -6.4e-6) {
		tmp = x + (-1.0 / x);
	} else if (z <= -1.3e-175) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= -1.55e-303) {
		tmp = x;
	} else if (z <= 3.9e-16) {
		tmp = x + (-1.0 / (-1.1283791670955126 / y));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -6.4e-6:
		tmp = x + (-1.0 / x)
	elif z <= -1.3e-175:
		tmp = x - (y * -0.8862269254527579)
	elif z <= -1.55e-303:
		tmp = x
	elif z <= 3.9e-16:
		tmp = x + (-1.0 / (-1.1283791670955126 / y))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -6.4e-6)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= -1.3e-175)
		tmp = Float64(x - Float64(y * -0.8862269254527579));
	elseif (z <= -1.55e-303)
		tmp = x;
	elseif (z <= 3.9e-16)
		tmp = Float64(x + Float64(-1.0 / Float64(-1.1283791670955126 / y)));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -6.4e-6)
		tmp = x + (-1.0 / x);
	elseif (z <= -1.3e-175)
		tmp = x - (y * -0.8862269254527579);
	elseif (z <= -1.55e-303)
		tmp = x;
	elseif (z <= 3.9e-16)
		tmp = x + (-1.0 / (-1.1283791670955126 / y));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -6.4e-6], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.3e-175], N[(x - N[(y * -0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.55e-303], x, If[LessEqual[z, 3.9e-16], N[(x + N[(-1.0 / N[(-1.1283791670955126 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]

Derivation

1. Split input into 4 regimes

2. if z < -6.3999999999999997e-6

   1. Initial program 91.5%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -6.3999999999999997e-6 < z < -1.3e-175

   1. Initial program 99.7%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 99.7%

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

   6. Taylor expanded in x around 0 78.5%

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

      1. *-commutative 78.5%

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

   8. Simplified 78.5%

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

   if -1.3e-175 < z < -1.55e-303 or 3.89999999999999977e-16 < z

   1. Initial program 96.8%

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

      1. +-commutative 96.8%

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

      2. div-inv 96.8%

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

      3. fma-def 96.7%

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

      4. *-commutative 96.7%

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

      5. *-commutative 96.7%

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

   4. Applied egg-rr 96.7%

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

   5. Taylor expanded in y around 0 94.8%

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

   if -1.55e-303 < z < 3.89999999999999977e-16

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.9%

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

   5. Taylor expanded in z around 0 99.8%

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

   6. Taylor expanded in x around 0 83.7%

      \[\leadsto x - \frac{1}{\color{blue}{\frac{-1.1283791670955126}{y}}} \]
3. Recombined 4 regimes into one program.

4. Final simplification 90.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -6.4 \cdot 10^{-6}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -1.3 \cdot 10^{-175}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq -1.55 \cdot 10^{-303}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 3.9 \cdot 10^{-16}:\\ \;\;\;\;x + \frac{-1}{\frac{-1.1283791670955126}{y}}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 70.3% accurate, 8.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -2.05 \cdot 10^{-163}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.75 \cdot 10^{-164}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-124}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.25 \cdot 10^{-121}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{elif}\;x \leq 5.2 \cdot 10^{-65}:\\ \;\;\;\;\frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -2.05e-163)
   x
   (if (<= x 1.75e-164)
     (* y 0.8862269254527579)
     (if (<= x 1.5e-124)
       x
       (if (<= x 1.25e-121)
         (* y 0.8862269254527579)
         (if (<= x 5.2e-65) (/ -1.0 x) x))))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -2.05e-163) {
		tmp = x;
	} else if (x <= 1.75e-164) {
		tmp = y * 0.8862269254527579;
	} else if (x <= 1.5e-124) {
		tmp = x;
	} else if (x <= 1.25e-121) {
		tmp = y * 0.8862269254527579;
	} else if (x <= 5.2e-65) {
		tmp = -1.0 / x;
	} 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-163)) then
        tmp = x
    else if (x <= 1.75d-164) then
        tmp = y * 0.8862269254527579d0
    else if (x <= 1.5d-124) then
        tmp = x
    else if (x <= 1.25d-121) then
        tmp = y * 0.8862269254527579d0
    else if (x <= 5.2d-65) then
        tmp = (-1.0d0) / x
    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-163) {
		tmp = x;
	} else if (x <= 1.75e-164) {
		tmp = y * 0.8862269254527579;
	} else if (x <= 1.5e-124) {
		tmp = x;
	} else if (x <= 1.25e-121) {
		tmp = y * 0.8862269254527579;
	} else if (x <= 5.2e-65) {
		tmp = -1.0 / x;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -2.05e-163:
		tmp = x
	elif x <= 1.75e-164:
		tmp = y * 0.8862269254527579
	elif x <= 1.5e-124:
		tmp = x
	elif x <= 1.25e-121:
		tmp = y * 0.8862269254527579
	elif x <= 5.2e-65:
		tmp = -1.0 / x
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -2.05e-163)
		tmp = x;
	elseif (x <= 1.75e-164)
		tmp = Float64(y * 0.8862269254527579);
	elseif (x <= 1.5e-124)
		tmp = x;
	elseif (x <= 1.25e-121)
		tmp = Float64(y * 0.8862269254527579);
	elseif (x <= 5.2e-65)
		tmp = Float64(-1.0 / x);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -2.05e-163)
		tmp = x;
	elseif (x <= 1.75e-164)
		tmp = y * 0.8862269254527579;
	elseif (x <= 1.5e-124)
		tmp = x;
	elseif (x <= 1.25e-121)
		tmp = y * 0.8862269254527579;
	elseif (x <= 5.2e-65)
		tmp = -1.0 / x;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -2.05e-163], x, If[LessEqual[x, 1.75e-164], N[(y * 0.8862269254527579), $MachinePrecision], If[LessEqual[x, 1.5e-124], x, If[LessEqual[x, 1.25e-121], N[(y * 0.8862269254527579), $MachinePrecision], If[LessEqual[x, 5.2e-65], N[(-1.0 / x), $MachinePrecision], x]]]]]

Derivation

1. Split input into 3 regimes

2. if x < -2.04999999999999991e-163 or 1.75e-164 < x < 1.5e-124 or 5.20000000000000019e-65 < x

   1. Initial program 97.8%

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

      1. +-commutative 97.8%

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

      2. div-inv 97.8%

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

      3. fma-def 97.8%

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

      4. *-commutative 97.8%

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

      5. *-commutative 97.8%

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

   4. Applied egg-rr 97.8%

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

   5. Taylor expanded in y around 0 86.3%

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

   if -2.04999999999999991e-163 < x < 1.75e-164 or 1.5e-124 < x < 1.24999999999999997e-121

   1. Initial program 93.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 68.2%

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

   6. Taylor expanded in y around 0 68.4%

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

   7. Taylor expanded in x around 0 51.6%

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

      1. *-commutative 51.6%

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

   9. Simplified 51.6%

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

   if 1.24999999999999997e-121 < x < 5.20000000000000019e-65

   1. Initial program 99.6%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 87.7%

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

   6. Taylor expanded in x around 0 87.7%

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

4. Final simplification 77.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -2.05 \cdot 10^{-163}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.75 \cdot 10^{-164}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{elif}\;x \leq 1.5 \cdot 10^{-124}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.25 \cdot 10^{-121}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{elif}\;x \leq 5.2 \cdot 10^{-65}:\\ \;\;\;\;\frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 85.7% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -2.2 \cdot 10^{-6}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -3 \cdot 10^{-175} \lor \neg \left(z \leq -4.2 \cdot 10^{-301}\right) \land z \leq 3.25 \cdot 10^{-16}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -2.2e-6)
   (+ x (/ -1.0 x))
   (if (or (<= z -3e-175) (and (not (<= z -4.2e-301)) (<= z 3.25e-16)))
     (- x (* y -0.8862269254527579))
     x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -2.2e-6) {
		tmp = x + (-1.0 / x);
	} else if ((z <= -3e-175) || (!(z <= -4.2e-301) && (z <= 3.25e-16))) {
		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 <= (-2.2d-6)) then
        tmp = x + ((-1.0d0) / x)
    else if ((z <= (-3d-175)) .or. (.not. (z <= (-4.2d-301))) .and. (z <= 3.25d-16)) 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 <= -2.2e-6) {
		tmp = x + (-1.0 / x);
	} else if ((z <= -3e-175) || (!(z <= -4.2e-301) && (z <= 3.25e-16))) {
		tmp = x - (y * -0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -2.2e-6:
		tmp = x + (-1.0 / x)
	elif (z <= -3e-175) or (not (z <= -4.2e-301) and (z <= 3.25e-16)):
		tmp = x - (y * -0.8862269254527579)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -2.2e-6)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif ((z <= -3e-175) || (!(z <= -4.2e-301) && (z <= 3.25e-16)))
		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 <= -2.2e-6)
		tmp = x + (-1.0 / x);
	elseif ((z <= -3e-175) || (~((z <= -4.2e-301)) && (z <= 3.25e-16)))
		tmp = x - (y * -0.8862269254527579);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -2.2e-6], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[z, -3e-175], And[N[Not[LessEqual[z, -4.2e-301]], $MachinePrecision], LessEqual[z, 3.25e-16]]], N[(x - N[(y * -0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -2.2000000000000001e-6

   1. Initial program 91.5%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -2.2000000000000001e-6 < z < -3e-175 or -4.1999999999999997e-301 < z < 3.25000000000000006e-16

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.9%

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

   5. Taylor expanded in z around 0 99.8%

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

   6. Taylor expanded in x around 0 81.4%

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

      1. *-commutative 81.4%

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

   8. Simplified 81.4%

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

   if -3e-175 < z < -4.1999999999999997e-301 or 3.25000000000000006e-16 < z

   1. Initial program 96.8%

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

      1. +-commutative 96.8%

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

      2. div-inv 96.8%

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

      3. fma-def 96.7%

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

      4. *-commutative 96.7%

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

      5. *-commutative 96.7%

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

   4. Applied egg-rr 96.7%

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

   5. Taylor expanded in y around 0 94.8%

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

4. Final simplification 90.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.2 \cdot 10^{-6}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -3 \cdot 10^{-175} \lor \neg \left(z \leq -4.2 \cdot 10^{-301}\right) \land z \leq 3.25 \cdot 10^{-16}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 85.8% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-7}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -3 \cdot 10^{-175}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq -4.2 \cdot 10^{-301}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 2.5 \cdot 10^{-16}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -8.5e-7)
   (+ x (/ -1.0 x))
   (if (<= z -3e-175)
     (- x (* y -0.8862269254527579))
     (if (<= z -4.2e-301)
       x
       (if (<= z 2.5e-16) (- x (/ y -1.1283791670955126)) x)))))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -8.5e-7) {
		tmp = x + (-1.0 / x);
	} else if (z <= -3e-175) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= -4.2e-301) {
		tmp = x;
	} else if (z <= 2.5e-16) {
		tmp = x - (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 (z <= (-8.5d-7)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= (-3d-175)) then
        tmp = x - (y * (-0.8862269254527579d0))
    else if (z <= (-4.2d-301)) then
        tmp = x
    else if (z <= 2.5d-16) then
        tmp = x - (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 (z <= -8.5e-7) {
		tmp = x + (-1.0 / x);
	} else if (z <= -3e-175) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= -4.2e-301) {
		tmp = x;
	} else if (z <= 2.5e-16) {
		tmp = x - (y / -1.1283791670955126);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -8.5e-7:
		tmp = x + (-1.0 / x)
	elif z <= -3e-175:
		tmp = x - (y * -0.8862269254527579)
	elif z <= -4.2e-301:
		tmp = x
	elif z <= 2.5e-16:
		tmp = x - (y / -1.1283791670955126)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -8.5e-7)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= -3e-175)
		tmp = Float64(x - Float64(y * -0.8862269254527579));
	elseif (z <= -4.2e-301)
		tmp = x;
	elseif (z <= 2.5e-16)
		tmp = Float64(x - Float64(y / -1.1283791670955126));
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (z <= -8.5e-7)
		tmp = x + (-1.0 / x);
	elseif (z <= -3e-175)
		tmp = x - (y * -0.8862269254527579);
	elseif (z <= -4.2e-301)
		tmp = x;
	elseif (z <= 2.5e-16)
		tmp = x - (y / -1.1283791670955126);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -8.5e-7], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -3e-175], N[(x - N[(y * -0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -4.2e-301], x, If[LessEqual[z, 2.5e-16], N[(x - N[(y / -1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]]]

Derivation

1. Split input into 4 regimes

2. if z < -8.50000000000000014e-7

   1. Initial program 91.5%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -8.50000000000000014e-7 < z < -3e-175

   1. Initial program 99.7%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 99.7%

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

   6. Taylor expanded in x around 0 78.5%

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

      1. *-commutative 78.5%

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

   8. Simplified 78.5%

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

   if -3e-175 < z < -4.1999999999999997e-301 or 2.5000000000000002e-16 < z

   1. Initial program 96.8%

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

      1. +-commutative 96.8%

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

      2. div-inv 96.8%

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

      3. fma-def 96.7%

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

      4. *-commutative 96.7%

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

      5. *-commutative 96.7%

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

   4. Applied egg-rr 96.7%

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

   5. Taylor expanded in y around 0 94.8%

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

   if -4.1999999999999997e-301 < z < 2.5000000000000002e-16

   1. Initial program 99.8%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.9%

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

   5. Taylor expanded in z around 0 99.8%

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

   6. Taylor expanded in x around 0 83.6%

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

      1. *-commutative 83.6%

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

   8. Simplified 83.6%

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

      1. metadata-eval 83.5%

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

      2. div-inv 83.6%

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

   10. Applied egg-rr 83.6%

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

4. Final simplification 90.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -8.5 \cdot 10^{-7}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq -3 \cdot 10^{-175}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq -4.2 \cdot 10^{-301}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 2.5 \cdot 10^{-16}:\\ \;\;\;\;x - \frac{y}{-1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 98.9% accurate, 8.5× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1150000.0)
   (+ x (/ -1.0 x))
   (if (<= z 4e-16) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1150000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 4e-16) {
		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 <= (-1150000.0d0)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= 4d-16) 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 <= -1150000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 4e-16) {
		tmp = x + (y / (1.1283791670955126 - (x * y)));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1150000.0:
		tmp = x + (-1.0 / x)
	elif z <= 4e-16:
		tmp = x + (y / (1.1283791670955126 - (x * y)))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1150000.0)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 4e-16)
		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 <= -1150000.0)
		tmp = x + (-1.0 / x);
	elseif (z <= 4e-16)
		tmp = x + (y / (1.1283791670955126 - (x * y)));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -1150000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4e-16], 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.15e6

   1. Initial program 90.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -1.15e6 < z < 3.9999999999999999e-16

   1. Initial program 99.8%

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

   3. Taylor expanded in z around 0 99.8%

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

   if 3.9999999999999999e-16 < z

   1. Initial program 95.3%

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

      1. +-commutative 95.3%

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

      2. div-inv 95.3%

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

      3. fma-def 95.3%

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

      4. *-commutative 95.3%

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

      5. *-commutative 95.3%

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

   4. Applied egg-rr 95.3%

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

   5. Taylor expanded in y around 0 100.0%

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

4. Final simplification 99.9%

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

Alternative 9: 73.0% accurate, 12.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -4 \cdot 10^{-162}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2.55 \cdot 10^{-116}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;x \leq 1.2 \cdot 10^{-61}:\\ \;\;\;\;\frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -4e-162)
   x
   (if (<= x 2.55e-116)
     (- x (* y -0.8862269254527579))
     (if (<= x 1.2e-61) (/ -1.0 x) x))))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -4e-162) {
		tmp = x;
	} else if (x <= 2.55e-116) {
		tmp = x - (y * -0.8862269254527579);
	} else if (x <= 1.2e-61) {
		tmp = -1.0 / x;
	} 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 <= (-4d-162)) then
        tmp = x
    else if (x <= 2.55d-116) then
        tmp = x - (y * (-0.8862269254527579d0))
    else if (x <= 1.2d-61) then
        tmp = (-1.0d0) / x
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= -4e-162) {
		tmp = x;
	} else if (x <= 2.55e-116) {
		tmp = x - (y * -0.8862269254527579);
	} else if (x <= 1.2e-61) {
		tmp = -1.0 / x;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -4e-162:
		tmp = x
	elif x <= 2.55e-116:
		tmp = x - (y * -0.8862269254527579)
	elif x <= 1.2e-61:
		tmp = -1.0 / x
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -4e-162)
		tmp = x;
	elseif (x <= 2.55e-116)
		tmp = Float64(x - Float64(y * -0.8862269254527579));
	elseif (x <= 1.2e-61)
		tmp = Float64(-1.0 / x);
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= -4e-162)
		tmp = x;
	elseif (x <= 2.55e-116)
		tmp = x - (y * -0.8862269254527579);
	elseif (x <= 1.2e-61)
		tmp = -1.0 / x;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -4e-162], x, If[LessEqual[x, 2.55e-116], N[(x - N[(y * -0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.2e-61], N[(-1.0 / x), $MachinePrecision], x]]]

Derivation

1. Split input into 3 regimes

2. if x < -3.99999999999999982e-162 or 1.2e-61 < x

   1. Initial program 97.6%

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

      1. +-commutative 97.6%

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

      2. div-inv 97.6%

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

      3. fma-def 97.6%

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

      4. *-commutative 97.6%

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

      5. *-commutative 97.6%

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

   4. Applied egg-rr 97.6%

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

   5. Taylor expanded in y around 0 88.5%

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

   if -3.99999999999999982e-162 < x < 2.5500000000000001e-116

   1. Initial program 94.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 70.9%

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

   6. Taylor expanded in x around 0 62.4%

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

      1. *-commutative 62.4%

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

   8. Simplified 62.4%

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

   if 2.5500000000000001e-116 < x < 1.2e-61

   1. Initial program 99.6%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 87.7%

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

   6. Taylor expanded in x around 0 87.7%

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

4. Final simplification 80.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -4 \cdot 10^{-162}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 2.55 \cdot 10^{-116}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;x \leq 1.2 \cdot 10^{-61}:\\ \;\;\;\;\frac{-1}{x}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 10: 70.4% accurate, 15.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -3.2 \cdot 10^{-164}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-163}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -3.2e-164) x (if (<= x 3.3e-163) (* y 0.8862269254527579) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -3.2e-164) {
		tmp = x;
	} else if (x <= 3.3e-163) {
		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 <= (-3.2d-164)) then
        tmp = x
    else if (x <= 3.3d-163) 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 <= -3.2e-164) {
		tmp = x;
	} else if (x <= 3.3e-163) {
		tmp = y * 0.8862269254527579;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -3.2e-164:
		tmp = x
	elif x <= 3.3e-163:
		tmp = y * 0.8862269254527579
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -3.2e-164)
		tmp = x;
	elseif (x <= 3.3e-163)
		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 <= -3.2e-164)
		tmp = x;
	elseif (x <= 3.3e-163)
		tmp = y * 0.8862269254527579;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -3.2e-164], x, If[LessEqual[x, 3.3e-163], N[(y * 0.8862269254527579), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -3.2e-164 or 3.30000000000000001e-163 < x

   1. Initial program 97.8%

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

      1. +-commutative 97.8%

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

      2. div-inv 97.8%

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

      3. fma-def 97.8%

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

      4. *-commutative 97.8%

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

      5. *-commutative 97.8%

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

   4. Applied egg-rr 97.8%

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

   5. Taylor expanded in y around 0 82.8%

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

   if -3.2e-164 < x < 3.30000000000000001e-163

   1. Initial program 93.9%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 67.8%

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

   6. Taylor expanded in y around 0 67.9%

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

   7. Taylor expanded in x around 0 50.9%

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

      1. *-commutative 50.9%

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

   9. Simplified 50.9%

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

4. Final simplification 74.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -3.2 \cdot 10^{-164}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 3.3 \cdot 10^{-163}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 11: 69.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 96.8%

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

   1. +-commutative 96.8%

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

   2. div-inv 96.8%

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

   3. fma-def 96.8%

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

   4. *-commutative 96.8%

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

   5. *-commutative 96.8%

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

4. Applied egg-rr 96.8%

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

5. Taylor expanded in y around 0 69.0%

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

6. Final simplification 69.0%

   \[\leadsto x \]
7. 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 2024013 
(FPCore (x y z)
  :name "Numeric.SpecFunctions:invErfc from math-functions-0.1.5.2, A"
  :precision binary64

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

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