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

Percentage Accurate: 95.7% → 99.9%

Time: 8.2s

Alternatives: 9

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.7% 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.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 94.1%

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

3. Simplified 100.0%

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

4. Final simplification 100.0%

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

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

Derivation

1. Split input into 3 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 81.8%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around inf 100.0%

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

   if 0.0 < (exp.f64 z) < 1

   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}{e^{z} \cdot \frac{1.1283791670955126}{y} - x}} \]

   4. Taylor expanded in z around 0 99.3%

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

      1. associate-*r/ 99.4%

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

      2. metadata-eval 99.4%

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

   6. Simplified 99.4%

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

   if 1 < (exp.f64 z)

   1. Initial program 94.6%

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

   2. Taylor expanded in z around 0 66.1%

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

      1. *-commutative 66.1%

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

   4. Simplified 66.1%

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

   5. 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}\;e^{z} \leq 0:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;e^{z} \leq 1:\\ \;\;\;\;x - \frac{-1}{\frac{1.1283791670955126}{y} - x}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 3: 98.5% accurate, 0.5× speedup

Math

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

FPCore

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

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 / ((exp(z) * 1.1283791670955126) - (x * y)));
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (exp(z) <= 0.0d0) then
        tmp = x + ((-1.0d0) / x)
    else
        tmp = x + (y / ((exp(z) * 1.1283791670955126d0) - (x * y)))
    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 {
		tmp = x + (y / ((Math.exp(z) * 1.1283791670955126) - (x * y)));
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if math.exp(z) <= 0.0:
		tmp = x + (-1.0 / x)
	else:
		tmp = x + (y / ((math.exp(z) * 1.1283791670955126) - (x * y)))
	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 / Float64(Float64(exp(z) * 1.1283791670955126) - Float64(x * y))));
	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);
	else
		tmp = x + (y / ((exp(z) * 1.1283791670955126) - (x * y)));
	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], N[(x + N[(y / N[(N[(N[Exp[z], $MachinePrecision] * 1.1283791670955126), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 81.8%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around inf 100.0%

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

   if 0.0 < (exp.f64 z)

   1. Initial program 98.3%

      \[x + \frac{y}{1.1283791670955126 \cdot e^{z} - x \cdot y} \]
3. Recombined 2 regimes into one program.

4. Final simplification 98.7%

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

Alternative 4: 84.9% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ \mathbf{if}\;z \leq -2.15 \cdot 10^{-11}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 1.35 \cdot 10^{-294}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq 2.32 \cdot 10^{-240}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 6.8 \cdot 10^{-128}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))))
   (if (<= z -2.15e-11)
     t_0
     (if (<= z 1.35e-294)
       (- x (* y -0.8862269254527579))
       (if (<= z 2.32e-240)
         t_0
         (if (<= z 6.8e-128) (+ x (/ y 1.1283791670955126)) x))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double tmp;
	if (z <= -2.15e-11) {
		tmp = t_0;
	} else if (z <= 1.35e-294) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= 2.32e-240) {
		tmp = t_0;
	} else if (z <= 6.8e-128) {
		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) :: t_0
    real(8) :: tmp
    t_0 = x + ((-1.0d0) / x)
    if (z <= (-2.15d-11)) then
        tmp = t_0
    else if (z <= 1.35d-294) then
        tmp = x - (y * (-0.8862269254527579d0))
    else if (z <= 2.32d-240) then
        tmp = t_0
    else if (z <= 6.8d-128) 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 t_0 = x + (-1.0 / x);
	double tmp;
	if (z <= -2.15e-11) {
		tmp = t_0;
	} else if (z <= 1.35e-294) {
		tmp = x - (y * -0.8862269254527579);
	} else if (z <= 2.32e-240) {
		tmp = t_0;
	} else if (z <= 6.8e-128) {
		tmp = x + (y / 1.1283791670955126);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	tmp = 0
	if z <= -2.15e-11:
		tmp = t_0
	elif z <= 1.35e-294:
		tmp = x - (y * -0.8862269254527579)
	elif z <= 2.32e-240:
		tmp = t_0
	elif z <= 6.8e-128:
		tmp = x + (y / 1.1283791670955126)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	tmp = 0.0
	if (z <= -2.15e-11)
		tmp = t_0;
	elseif (z <= 1.35e-294)
		tmp = Float64(x - Float64(y * -0.8862269254527579));
	elseif (z <= 2.32e-240)
		tmp = t_0;
	elseif (z <= 6.8e-128)
		tmp = Float64(x + Float64(y / 1.1283791670955126));
	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 <= -2.15e-11)
		tmp = t_0;
	elseif (z <= 1.35e-294)
		tmp = x - (y * -0.8862269254527579);
	elseif (z <= 2.32e-240)
		tmp = t_0;
	elseif (z <= 6.8e-128)
		tmp = x + (y / 1.1283791670955126);
	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, -2.15e-11], t$95$0, If[LessEqual[z, 1.35e-294], N[(x - N[(y * -0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 2.32e-240], t$95$0, If[LessEqual[z, 6.8e-128], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]]]]

Derivation

1. Split input into 4 regimes

2. if z < -2.15000000000000001e-11 or 1.35000000000000005e-294 < z < 2.3199999999999999e-240

   1. Initial program 86.2%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around inf 96.5%

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

   if -2.15000000000000001e-11 < z < 1.35000000000000005e-294

   1. Initial program 99.8%

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

   2. Taylor expanded in z around 0 99.8%

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

      1. *-commutative 99.8%

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

   4. Simplified 99.8%

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

   5. Taylor expanded in y around 0 78.3%

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

      1. metadata-eval 78.3%

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

      2. cancel-sign-sub-inv 78.3%

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

      3. *-commutative 78.3%

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

   7. Simplified 78.3%

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

   if 2.3199999999999999e-240 < z < 6.7999999999999995e-128

   1. Initial program 99.9%

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

   2. Taylor expanded in z around 0 99.9%

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

      1. *-commutative 99.9%

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

   4. Simplified 99.9%

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

   5. Taylor expanded in y around 0 77.7%

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

   if 6.7999999999999995e-128 < z

   1. Initial program 96.4%

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

   2. Taylor expanded in z around 0 77.1%

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

      1. *-commutative 77.1%

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

   4. Simplified 77.1%

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

   5. Taylor expanded in x around inf 96.6%

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

4. Final simplification 90.3%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -2.15 \cdot 10^{-11}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 1.35 \cdot 10^{-294}:\\ \;\;\;\;x - y \cdot -0.8862269254527579\\ \mathbf{elif}\;z \leq 2.32 \cdot 10^{-240}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 6.8 \cdot 10^{-128}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 5: 98.4% accurate, 8.5× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -175.0)
   (+ x (/ -1.0 x))
   (if (<= z 7.5e-35) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))

C

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

Python

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

Julia

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

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -175.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 7.5e-35], 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 < -175

   1. Initial program 81.8%

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

   3. Simplified 100.0%

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

   4. Taylor expanded in y around inf 100.0%

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

   if -175 < z < 7.5e-35

   1. Initial program 99.8%

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

   2. Taylor expanded in z around 0 99.3%

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

      1. *-commutative 99.3%

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

   4. Simplified 99.3%

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

   if 7.5e-35 < z

   1. Initial program 95.2%

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

   2. Taylor expanded in z around 0 69.4%

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

      1. *-commutative 69.4%

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

   4. Simplified 69.4%

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

   5. Taylor expanded in x around inf 100.0%

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

4. Final simplification 99.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -175:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 7.5 \cdot 10^{-35}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 6: 72.1% accurate, 12.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1.1 \cdot 10^{-128}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.45 \cdot 10^{-266}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1.1e-128)
   x
   (if (<= x 1.45e-266) (+ x (/ y 1.1283791670955126)) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1.1e-128) {
		tmp = x;
	} else if (x <= 1.45e-266) {
		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 (x <= (-1.1d-128)) then
        tmp = x
    else if (x <= 1.45d-266) 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 (x <= -1.1e-128) {
		tmp = x;
	} else if (x <= 1.45e-266) {
		tmp = x + (y / 1.1283791670955126);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1.1e-128:
		tmp = x
	elif x <= 1.45e-266:
		tmp = x + (y / 1.1283791670955126)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1.1e-128)
		tmp = x;
	elseif (x <= 1.45e-266)
		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 (x <= -1.1e-128)
		tmp = x;
	elseif (x <= 1.45e-266)
		tmp = x + (y / 1.1283791670955126);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1.1e-128], x, If[LessEqual[x, 1.45e-266], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -1.10000000000000005e-128 or 1.44999999999999998e-266 < x

   1. Initial program 97.4%

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

   2. Taylor expanded in z around 0 83.8%

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

      1. *-commutative 83.8%

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

   4. Simplified 83.8%

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

   5. Taylor expanded in x around inf 79.4%

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

   if -1.10000000000000005e-128 < x < 1.44999999999999998e-266

   1. Initial program 79.6%

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

   2. Taylor expanded in z around 0 54.9%

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

      1. *-commutative 54.9%

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

   4. Simplified 54.9%

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

   5. Taylor expanded in y around 0 45.2%

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

4. Final simplification 73.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1.1 \cdot 10^{-128}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 1.45 \cdot 10^{-266}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 7: 70.8% accurate, 15.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -6.5 \cdot 10^{-168}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 10^{-266}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -6.5e-168) x (if (<= x 1e-266) (* y 0.8862269254527579) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -6.5e-168) {
		tmp = x;
	} else if (x <= 1e-266) {
		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 <= (-6.5d-168)) then
        tmp = x
    else if (x <= 1d-266) 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 <= -6.5e-168) {
		tmp = x;
	} else if (x <= 1e-266) {
		tmp = y * 0.8862269254527579;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -6.5e-168:
		tmp = x
	elif x <= 1e-266:
		tmp = y * 0.8862269254527579
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -6.5e-168)
		tmp = x;
	elseif (x <= 1e-266)
		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 <= -6.5e-168)
		tmp = x;
	elseif (x <= 1e-266)
		tmp = y * 0.8862269254527579;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -6.5e-168], x, If[LessEqual[x, 1e-266], N[(y * 0.8862269254527579), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -6.4999999999999997e-168 or 9.9999999999999998e-267 < x

   1. Initial program 97.4%

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

   2. Taylor expanded in z around 0 84.2%

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

      1. *-commutative 84.2%

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

   4. Simplified 84.2%

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

   5. Taylor expanded in x around inf 78.7%

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

   if -6.4999999999999997e-168 < x < 9.9999999999999998e-267

   1. Initial program 76.7%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in z around 0 48.2%

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

      1. frac-2neg 48.2%

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

      2. metadata-eval 48.2%

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

      3. inv-pow 48.2%

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

      4. un-div-inv 48.4%

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

   6. Applied egg-rr 48.4%

      \[\leadsto x - \color{blue}{{\left(-\left(\frac{1.1283791670955126}{y} - x\right)\right)}^{-1}} \]
   7. Step-by-step derivation

      1. unpow-1 48.4%

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

      2. sub-neg 48.4%

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

      3. +-commutative 48.4%

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

      4. distribute-neg-in 48.4%

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

      5. remove-double-neg 48.4%

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

      6. distribute-neg-frac 48.4%

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

      7. metadata-eval 48.4%

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

   8. Simplified 48.4%

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

   9. Taylor expanded in x around 0 36.8%

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

       1. *-commutative 36.8%

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

   11. Simplified 36.8%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -6.5 \cdot 10^{-168}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 10^{-266}:\\ \;\;\;\;y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 8: 70.7% accurate, 15.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq -1 \cdot 10^{-173}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 5.9 \cdot 10^{-268}:\\ \;\;\;\;\frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= x -1e-173) x (if (<= x 5.9e-268) (/ y 1.1283791670955126) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= -1e-173) {
		tmp = x;
	} else if (x <= 5.9e-268) {
		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 <= (-1d-173)) then
        tmp = x
    else if (x <= 5.9d-268) 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 <= -1e-173) {
		tmp = x;
	} else if (x <= 5.9e-268) {
		tmp = y / 1.1283791670955126;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= -1e-173:
		tmp = x
	elif x <= 5.9e-268:
		tmp = y / 1.1283791670955126
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= -1e-173)
		tmp = x;
	elseif (x <= 5.9e-268)
		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 <= -1e-173)
		tmp = x;
	elseif (x <= 5.9e-268)
		tmp = y / 1.1283791670955126;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, -1e-173], x, If[LessEqual[x, 5.9e-268], N[(y / 1.1283791670955126), $MachinePrecision], x]]

Derivation

1. Split input into 2 regimes

2. if x < -1e-173 or 5.89999999999999995e-268 < x

   1. Initial program 97.4%

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

   2. Taylor expanded in z around 0 84.2%

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

      1. *-commutative 84.2%

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

   4. Simplified 84.2%

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

   5. Taylor expanded in x around inf 78.7%

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

   if -1e-173 < x < 5.89999999999999995e-268

   1. Initial program 76.7%

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

   3. Simplified 99.9%

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

   4. Taylor expanded in y around 0 51.4%

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

      1. associate-*r/ 51.4%

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

   6. Simplified 51.4%

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

   7. Taylor expanded in x around 0 40.3%

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

      1. associate-*r/ 40.3%

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

      2. *-commutative 40.3%

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

      3. associate-/l* 40.4%

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

   9. Simplified 40.4%

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

   10. Taylor expanded in z around 0 36.9%

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

4. Final simplification 72.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;x \leq -1 \cdot 10^{-173}:\\ \;\;\;\;x\\ \mathbf{elif}\;x \leq 5.9 \cdot 10^{-268}:\\ \;\;\;\;\frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]

Alternative 9: 69.2% 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 94.1%

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

2. Taylor expanded in z around 0 78.5%

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

   1. *-commutative 78.5%

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

4. Simplified 78.5%

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

5. Taylor expanded in x around inf 68.4%

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

6. Final simplification 68.4%

   \[\leadsto x \]

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 2023310 
(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)))))