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

Percentage Accurate: 95.6% → 99.6%

Time: 9.4s

Alternatives: 9

Speedup: 5.8×

Specification

Math

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

FPCore

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

C

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

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = x + (y / ((1.1283791670955126d0 * exp(z)) - (x * y)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 95.6% 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.6% accurate, 0.4× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	double tmp;
	if (exp(z) <= 0.0) {
		tmp = x + (-1.0 / x);
	} else if (exp(z) <= 1.0000002) {
		tmp = x + (y / (1.1283791670955126 - (x * y)));
	} else {
		tmp = x + (y / (exp(z) * 1.1283791670955126));
	}
	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.0000002d0) then
        tmp = x + (y / (1.1283791670955126d0 - (x * y)))
    else
        tmp = x + (y / (exp(z) * 1.1283791670955126d0))
    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.0000002) {
		tmp = x + (y / (1.1283791670955126 - (x * y)));
	} else {
		tmp = x + (y / (Math.exp(z) * 1.1283791670955126));
	}
	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.0000002:
		tmp = x + (y / (1.1283791670955126 - (x * y)))
	else:
		tmp = x + (y / (math.exp(z) * 1.1283791670955126))
	return tmp

Julia

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

Derivation

1. Split input into 3 regimes

2. if (exp.f64 z) < 0.0

   1. Initial program 92.3%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if 0.0 < (exp.f64 z) < 1.00000019999999989

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 99.9%

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

      1. *-commutative 99.9%

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

   5. Simplified 99.9%

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

   if 1.00000019999999989 < (exp.f64 z)

   1. Initial program 92.3%

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

   3. Taylor expanded in x around 0 100.0%

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

      1. *-commutative 100.0%

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

   5. Simplified 100.0%

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

Alternative 2: 99.9% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 96.1%

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

3. Simplified 99.9%

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

5. Final simplification 99.9%

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

Alternative 3: 99.5% accurate, 4.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if z < -6.7e10

   1. Initial program 91.8%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -6.7e10 < z < 53

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 99.2%

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

      1. *-commutative 99.2%

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

      2. *-commutative 99.2%

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

   5. Simplified 99.2%

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

   if 53 < z

   1. Initial program 92.1%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 66.2%

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

      1. associate-*r/ 66.2%

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

      2. metadata-eval 66.2%

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

   7. Simplified 66.2%

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

   8. 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 -67000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 53:\\ \;\;\;\;x + \frac{y}{\left(1.1283791670955126 + z \cdot 1.1283791670955126\right) - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 99.4% accurate, 5.8× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -67000000000.0)
   (+ x (/ -1.0 x))
   (if (<= z 53.0) (+ x (/ -1.0 (- x (/ 1.1283791670955126 y)))) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -67000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 53.0) {
		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 (z <= (-67000000000.0d0)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= 53.0d0) 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 (z <= -67000000000.0) {
		tmp = x + (-1.0 / x);
	} else if (z <= 53.0) {
		tmp = x + (-1.0 / (x - (1.1283791670955126 / y)));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -67000000000.0], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 53.0], 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 z < -6.7e10

   1. Initial program 91.8%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -6.7e10 < z < 53

   1. Initial program 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in z around 0 99.2%

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

      1. associate-*r/ 99.2%

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

      2. metadata-eval 99.2%

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

   7. Simplified 99.2%

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

   if 53 < z

   1. Initial program 92.1%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 66.2%

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

      1. associate-*r/ 66.2%

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

      2. metadata-eval 66.2%

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

   7. Simplified 66.2%

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

   8. 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 -67000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 53:\\ \;\;\;\;x + \frac{-1}{x - \frac{1.1283791670955126}{y}}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 99.4% accurate, 5.8× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 3 regimes

2. if z < -6.7e10

   1. Initial program 91.8%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 100.0%

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

   if -6.7e10 < z < 53

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 99.2%

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

      1. *-commutative 99.2%

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

   5. Simplified 99.2%

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

   if 53 < z

   1. Initial program 92.1%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 66.2%

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

      1. associate-*r/ 66.2%

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

      2. metadata-eval 66.2%

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

   7. Simplified 66.2%

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

   8. 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 -67000000000:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 53:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 6: 73.0% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -1.3 \cdot 10^{-99}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 9.8 \cdot 10^{-21}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -1.3e-99) x (if (<= z 9.8e-21) (+ x (* y 0.8862269254527579)) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -1.3e-99) {
		tmp = x;
	} else if (z <= 9.8e-21) {
		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 <= (-1.3d-99)) then
        tmp = x
    else if (z <= 9.8d-21) 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 <= -1.3e-99) {
		tmp = x;
	} else if (z <= 9.8e-21) {
		tmp = x + (y * 0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -1.3e-99:
		tmp = x
	elif z <= 9.8e-21:
		tmp = x + (y * 0.8862269254527579)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -1.3e-99)
		tmp = x;
	elseif (z <= 9.8e-21)
		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 <= -1.3e-99)
		tmp = x;
	elseif (z <= 9.8e-21)
		tmp = x + (y * 0.8862269254527579);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if z < -1.30000000000000003e-99 or 9.8000000000000003e-21 < z

   1. Initial program 93.7%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 74.4%

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

      1. associate-*r/ 74.4%

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

      2. metadata-eval 74.4%

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

   7. Simplified 74.4%

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

   8. Taylor expanded in x around inf 79.5%

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

   if -1.30000000000000003e-99 < z < 9.8000000000000003e-21

   1. Initial program 99.9%

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

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 99.8%

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

      1. associate-*r/ 99.8%

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

      2. metadata-eval 99.8%

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

   7. Simplified 99.8%

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

   8. Taylor expanded in x around 0 83.6%

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

      1. *-commutative 83.6%

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

   10. Simplified 83.6%

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

4. Final simplification 81.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -1.3 \cdot 10^{-99}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 9.8 \cdot 10^{-21}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 85.8% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -9 \cdot 10^{-122}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 1.28 \cdot 10^{-20}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -9e-122)
   (+ x (/ -1.0 x))
   (if (<= z 1.28e-20) (+ x (* y 0.8862269254527579)) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -9e-122) {
		tmp = x + (-1.0 / x);
	} else if (z <= 1.28e-20) {
		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 <= (-9d-122)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= 1.28d-20) 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 <= -9e-122) {
		tmp = x + (-1.0 / x);
	} else if (z <= 1.28e-20) {
		tmp = x + (y * 0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -9e-122:
		tmp = x + (-1.0 / x)
	elif z <= 1.28e-20:
		tmp = x + (y * 0.8862269254527579)
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -9e-122)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 1.28e-20)
		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 <= -9e-122)
		tmp = x + (-1.0 / x);
	elseif (z <= 1.28e-20)
		tmp = x + (y * 0.8862269254527579);
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -9e-122], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.28e-20], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -8.99999999999999959e-122

   1. Initial program 94.6%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 94.7%

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

   if -8.99999999999999959e-122 < z < 1.2800000000000001e-20

   1. Initial program 99.9%

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

   3. Simplified 99.8%

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

   5. Taylor expanded in z around 0 99.8%

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

      1. associate-*r/ 99.8%

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

      2. metadata-eval 99.8%

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

   7. Simplified 99.8%

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

   8. Taylor expanded in x around 0 84.9%

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

      1. *-commutative 84.9%

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

   10. Simplified 84.9%

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

   if 1.2800000000000001e-20 < z

   1. Initial program 92.8%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 67.9%

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

      1. associate-*r/ 67.9%

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

      2. metadata-eval 67.9%

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

   7. Simplified 67.9%

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

   8. Taylor expanded in x around inf 98.6%

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

4. Final simplification 92.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;z \leq -9 \cdot 10^{-122}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 1.28 \cdot 10^{-20}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 85.9% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -7 \cdot 10^{-119}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 1.4 \cdot 10^{-20}:\\ \;\;\;\;x + \frac{y}{1.1283791670955126}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -7e-119)
   (+ x (/ -1.0 x))
   (if (<= z 1.4e-20) (+ x (/ y 1.1283791670955126)) x)))

C

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

Python

def code(x, y, z):
	tmp = 0
	if z <= -7e-119:
		tmp = x + (-1.0 / x)
	elif z <= 1.4e-20:
		tmp = x + (y / 1.1283791670955126)
	else:
		tmp = x
	return tmp

Julia

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

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -7e-119], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.4e-20], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]

Derivation

1. Split input into 3 regimes

2. if z < -7e-119

   1. Initial program 94.6%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in x around inf 94.7%

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

   if -7e-119 < z < 1.4000000000000001e-20

   1. Initial program 99.9%

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

   3. Taylor expanded in z around 0 99.9%

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

      1. *-commutative 99.9%

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

      2. *-commutative 99.9%

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

   5. Simplified 99.9%

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

   6. Taylor expanded in y around 0 85.0%

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

   7. Taylor expanded in z around 0 85.0%

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

   if 1.4000000000000001e-20 < z

   1. Initial program 92.8%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in z around 0 67.9%

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

      1. associate-*r/ 67.9%

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

      2. metadata-eval 67.9%

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

   7. Simplified 67.9%

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

   8. Taylor expanded in x around inf 98.6%

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

4. Final simplification 92.1%

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

Alternative 9: 68.6% 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.1%

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

3. Simplified 99.9%

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

5. Taylor expanded in z around 0 84.3%

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

   1. associate-*r/ 84.3%

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

   2. metadata-eval 84.3%

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

7. Simplified 84.3%

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

8. Taylor expanded in x around inf 73.8%

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

9. Final simplification 73.8%

   \[\leadsto x \]
10. 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 2024034 
(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)))))