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

Percentage Accurate: 96.0% → 99.3%

Time: 8.5s

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: 96.0% 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.3% 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:\\ \;\;\;\;x + \frac{y}{1.1283791670955126 - x \cdot y}\\ \mathbf{else}:\\ \;\;\;\;x + \frac{y \cdot 0.8862269254527579}{e^{z}}\\ \end{array} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. 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

&prev;&pcontext;&pcontext2;&ctx;
1. 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

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 84.7% accurate, 5.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ \mathbf{if}\;z \leq -1.15 \cdot 10^{-145}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -1.6 \cdot 10^{-207}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{elif}\;z \leq -2.4 \cdot 10^{-240}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 3.2 \cdot 10^{-297}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 0.46:\\ \;\;\;\;x + 0.8862269254527579 \cdot \frac{y}{z + 1}\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))))
   (if (<= z -1.15e-145)
     t_0
     (if (<= z -1.6e-207)
       (+ x (* y 0.8862269254527579))
       (if (<= z -2.4e-240)
         t_0
         (if (<= z 3.2e-297)
           x
           (if (<= z 0.46)
             (+ x (* 0.8862269254527579 (/ y (+ z 1.0))))
             x)))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double tmp;
	if (z <= -1.15e-145) {
		tmp = t_0;
	} else if (z <= -1.6e-207) {
		tmp = x + (y * 0.8862269254527579);
	} else if (z <= -2.4e-240) {
		tmp = t_0;
	} else if (z <= 3.2e-297) {
		tmp = x;
	} else if (z <= 0.46) {
		tmp = x + (0.8862269254527579 * (y / (z + 1.0)));
	} 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 <= (-1.15d-145)) then
        tmp = t_0
    else if (z <= (-1.6d-207)) then
        tmp = x + (y * 0.8862269254527579d0)
    else if (z <= (-2.4d-240)) then
        tmp = t_0
    else if (z <= 3.2d-297) then
        tmp = x
    else if (z <= 0.46d0) then
        tmp = x + (0.8862269254527579d0 * (y / (z + 1.0d0)))
    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 <= -1.15e-145) {
		tmp = t_0;
	} else if (z <= -1.6e-207) {
		tmp = x + (y * 0.8862269254527579);
	} else if (z <= -2.4e-240) {
		tmp = t_0;
	} else if (z <= 3.2e-297) {
		tmp = x;
	} else if (z <= 0.46) {
		tmp = x + (0.8862269254527579 * (y / (z + 1.0)));
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	tmp = 0
	if z <= -1.15e-145:
		tmp = t_0
	elif z <= -1.6e-207:
		tmp = x + (y * 0.8862269254527579)
	elif z <= -2.4e-240:
		tmp = t_0
	elif z <= 3.2e-297:
		tmp = x
	elif z <= 0.46:
		tmp = x + (0.8862269254527579 * (y / (z + 1.0)))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	tmp = 0.0
	if (z <= -1.15e-145)
		tmp = t_0;
	elseif (z <= -1.6e-207)
		tmp = Float64(x + Float64(y * 0.8862269254527579));
	elseif (z <= -2.4e-240)
		tmp = t_0;
	elseif (z <= 3.2e-297)
		tmp = x;
	elseif (z <= 0.46)
		tmp = Float64(x + Float64(0.8862269254527579 * Float64(y / Float64(z + 1.0))));
	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 <= -1.15e-145)
		tmp = t_0;
	elseif (z <= -1.6e-207)
		tmp = x + (y * 0.8862269254527579);
	elseif (z <= -2.4e-240)
		tmp = t_0;
	elseif (z <= 3.2e-297)
		tmp = x;
	elseif (z <= 0.46)
		tmp = x + (0.8862269254527579 * (y / (z + 1.0)));
	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, -1.15e-145], t$95$0, If[LessEqual[z, -1.6e-207], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.4e-240], t$95$0, If[LessEqual[z, 3.2e-297], x, If[LessEqual[z, 0.46], N[(x + N[(0.8862269254527579 * N[(y / N[(z + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 99.0% accurate, 6.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;z \leq -3.5 \cdot 10^{+22}:\\ \;\;\;\;x + \frac{-1}{x}\\ \mathbf{elif}\;z \leq 260:\\ \;\;\;\;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 -3.5e+22)
   (+ x (/ -1.0 x))
   (if (<= z 260.0)
     (+ x (/ y (- (+ 1.1283791670955126 (* z 1.1283791670955126)) (* x y))))
     x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -3.5e+22) {
		tmp = x + (-1.0 / x);
	} else if (z <= 260.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 <= (-3.5d+22)) then
        tmp = x + ((-1.0d0) / x)
    else if (z <= 260.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 <= -3.5e+22) {
		tmp = x + (-1.0 / x);
	} else if (z <= 260.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 <= -3.5e+22:
		tmp = x + (-1.0 / x)
	elif z <= 260.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 <= -3.5e+22)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 260.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 <= -3.5e+22)
		tmp = x + (-1.0 / x);
	elseif (z <= 260.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, -3.5e+22], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 260.0], N[(x + N[(y / N[(N[(1.1283791670955126 + N[(z * 1.1283791670955126), $MachinePrecision]), $MachinePrecision] - N[(x * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 84.6% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ t_1 := x + y \cdot 0.8862269254527579\\ \mathbf{if}\;z \leq -7.8 \cdot 10^{-146}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -5.1 \cdot 10^{-207}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;z \leq -7.6 \cdot 10^{-239}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 3.4 \cdot 10^{-297}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 2.6:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;x\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ x (/ -1.0 x))) (t_1 (+ x (* y 0.8862269254527579))))
   (if (<= z -7.8e-146)
     t_0
     (if (<= z -5.1e-207)
       t_1
       (if (<= z -7.6e-239)
         t_0
         (if (<= z 3.4e-297) x (if (<= z 2.6) t_1 x)))))))

C

double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x + (y * 0.8862269254527579);
	double tmp;
	if (z <= -7.8e-146) {
		tmp = t_0;
	} else if (z <= -5.1e-207) {
		tmp = t_1;
	} else if (z <= -7.6e-239) {
		tmp = t_0;
	} else if (z <= 3.4e-297) {
		tmp = x;
	} else if (z <= 2.6) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = x + ((-1.0d0) / x)
    t_1 = x + (y * 0.8862269254527579d0)
    if (z <= (-7.8d-146)) then
        tmp = t_0
    else if (z <= (-5.1d-207)) then
        tmp = t_1
    else if (z <= (-7.6d-239)) then
        tmp = t_0
    else if (z <= 3.4d-297) then
        tmp = x
    else if (z <= 2.6d0) then
        tmp = t_1
    else
        tmp = x
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x + (-1.0 / x);
	double t_1 = x + (y * 0.8862269254527579);
	double tmp;
	if (z <= -7.8e-146) {
		tmp = t_0;
	} else if (z <= -5.1e-207) {
		tmp = t_1;
	} else if (z <= -7.6e-239) {
		tmp = t_0;
	} else if (z <= 3.4e-297) {
		tmp = x;
	} else if (z <= 2.6) {
		tmp = t_1;
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x + (-1.0 / x)
	t_1 = x + (y * 0.8862269254527579)
	tmp = 0
	if z <= -7.8e-146:
		tmp = t_0
	elif z <= -5.1e-207:
		tmp = t_1
	elif z <= -7.6e-239:
		tmp = t_0
	elif z <= 3.4e-297:
		tmp = x
	elif z <= 2.6:
		tmp = t_1
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x + Float64(-1.0 / x))
	t_1 = Float64(x + Float64(y * 0.8862269254527579))
	tmp = 0.0
	if (z <= -7.8e-146)
		tmp = t_0;
	elseif (z <= -5.1e-207)
		tmp = t_1;
	elseif (z <= -7.6e-239)
		tmp = t_0;
	elseif (z <= 3.4e-297)
		tmp = x;
	elseif (z <= 2.6)
		tmp = t_1;
	else
		tmp = x;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x + (-1.0 / x);
	t_1 = x + (y * 0.8862269254527579);
	tmp = 0.0;
	if (z <= -7.8e-146)
		tmp = t_0;
	elseif (z <= -5.1e-207)
		tmp = t_1;
	elseif (z <= -7.6e-239)
		tmp = t_0;
	elseif (z <= 3.4e-297)
		tmp = x;
	elseif (z <= 2.6)
		tmp = t_1;
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -7.8e-146], t$95$0, If[LessEqual[z, -5.1e-207], t$95$1, If[LessEqual[z, -7.6e-239], t$95$0, If[LessEqual[z, 3.4e-297], x, If[LessEqual[z, 2.6], t$95$1, x]]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 84.6% accurate, 7.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x + \frac{-1}{x}\\ \mathbf{if}\;z \leq -1.55 \cdot 10^{-147}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq -7.5 \cdot 10^{-207}:\\ \;\;\;\;x + y \cdot 0.8862269254527579\\ \mathbf{elif}\;z \leq -2.4 \cdot 10^{-240}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;z \leq 4.5 \cdot 10^{-297}:\\ \;\;\;\;x\\ \mathbf{elif}\;z \leq 0.08:\\ \;\;\;\;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 -1.55e-147)
     t_0
     (if (<= z -7.5e-207)
       (+ x (* y 0.8862269254527579))
       (if (<= z -2.4e-240)
         t_0
         (if (<= z 4.5e-297)
           x
           (if (<= z 0.08) (+ 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 <= -1.55e-147) {
		tmp = t_0;
	} else if (z <= -7.5e-207) {
		tmp = x + (y * 0.8862269254527579);
	} else if (z <= -2.4e-240) {
		tmp = t_0;
	} else if (z <= 4.5e-297) {
		tmp = x;
	} else if (z <= 0.08) {
		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 <= (-1.55d-147)) then
        tmp = t_0
    else if (z <= (-7.5d-207)) then
        tmp = x + (y * 0.8862269254527579d0)
    else if (z <= (-2.4d-240)) then
        tmp = t_0
    else if (z <= 4.5d-297) then
        tmp = x
    else if (z <= 0.08d0) 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 <= -1.55e-147) {
		tmp = t_0;
	} else if (z <= -7.5e-207) {
		tmp = x + (y * 0.8862269254527579);
	} else if (z <= -2.4e-240) {
		tmp = t_0;
	} else if (z <= 4.5e-297) {
		tmp = x;
	} else if (z <= 0.08) {
		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 <= -1.55e-147:
		tmp = t_0
	elif z <= -7.5e-207:
		tmp = x + (y * 0.8862269254527579)
	elif z <= -2.4e-240:
		tmp = t_0
	elif z <= 4.5e-297:
		tmp = x
	elif z <= 0.08:
		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 <= -1.55e-147)
		tmp = t_0;
	elseif (z <= -7.5e-207)
		tmp = Float64(x + Float64(y * 0.8862269254527579));
	elseif (z <= -2.4e-240)
		tmp = t_0;
	elseif (z <= 4.5e-297)
		tmp = x;
	elseif (z <= 0.08)
		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 <= -1.55e-147)
		tmp = t_0;
	elseif (z <= -7.5e-207)
		tmp = x + (y * 0.8862269254527579);
	elseif (z <= -2.4e-240)
		tmp = t_0;
	elseif (z <= 4.5e-297)
		tmp = x;
	elseif (z <= 0.08)
		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, -1.55e-147], t$95$0, If[LessEqual[z, -7.5e-207], N[(x + N[(y * 0.8862269254527579), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -2.4e-240], t$95$0, If[LessEqual[z, 4.5e-297], x, If[LessEqual[z, 0.08], N[(x + N[(y / 1.1283791670955126), $MachinePrecision]), $MachinePrecision], x]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 98.9% accurate, 8.5× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -3.5e+22)
   (+ x (/ -1.0 x))
   (if (<= z 350.0) (+ x (/ 1.0 (- (/ 1.1283791670955126 y) x))) x)))

C

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

Python

def code(x, y, z):
	tmp = 0
	if z <= -3.5e+22:
		tmp = x + (-1.0 / x)
	elif z <= 350.0:
		tmp = x + (1.0 / ((1.1283791670955126 / y) - x))
	else:
		tmp = x
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (z <= -3.5e+22)
		tmp = Float64(x + Float64(-1.0 / x));
	elseif (z <= 350.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 (z <= -3.5e+22)
		tmp = x + (-1.0 / x);
	elseif (z <= 350.0)
		tmp = x + (1.0 / ((1.1283791670955126 / y) - x));
	else
		tmp = x;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[z, -3.5e+22], N[(x + N[(-1.0 / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 350.0], N[(x + N[(1.0 / N[(N[(1.1283791670955126 / y), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], x]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 98.9% accurate, 8.5× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -3.5e+22)
   (+ x (/ -1.0 x))
   (if (<= z 260.0) (+ x (/ y (- 1.1283791670955126 (* x y)))) x)))

C

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

Python

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

Julia

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 72.9% accurate, 12.2× speedup

Math

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

FPCore

(FPCore (x y z)
 :precision binary64
 (if (<= z -9e-148) x (if (<= z 0.08) (+ x (* y 0.8862269254527579)) x)))

C

double code(double x, double y, double z) {
	double tmp;
	if (z <= -9e-148) {
		tmp = x;
	} else if (z <= 0.08) {
		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-148)) then
        tmp = x
    else if (z <= 0.08d0) 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-148) {
		tmp = x;
	} else if (z <= 0.08) {
		tmp = x + (y * 0.8862269254527579);
	} else {
		tmp = x;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if z <= -9e-148:
		tmp = x
	elif z <= 0.08:
		tmp = x + (y * 0.8862269254527579)
	else:
		tmp = x
	return tmp

Julia

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 68.4% 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

&prev;&pcontext;&pcontext2;&ctx;
1. 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 2023350 
(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)))))