Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 26.1s

Alternatives: 25

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = -2.8799668842992932e-154
  2. Ec = 6.642839115088406e+195
  3. Vef = -3.175502652675293e+275
  4. EDonor = 2.8185842057865055e+44
  5. mu = -1.888089745544832e-148
  6. KbT = 4.9697031916613614e-282
  7. NaChar = 1.295065730580476e-154
  8. Ev = -9.96799245580718e+33
  9. EAccept = 3.235009071294204e-168

Specification

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{-\left(\left(\left(Ec - Vef\right) - EDonor\right) - mu\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{\left(\left(Ev + Vef\right) + EAccept\right) + \left(-mu\right)}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (1.0d0 + exp((-(((ec - vef) - edonor) - mu) / kbt)))) + (nachar / (1.0d0 + exp(((((ev + vef) + eaccept) + -mu) / kbt))))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + Math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + Math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + math.exp(((((Ev + Vef) + EAccept) + -mu) / KbT))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Float64(Float64(Float64(Ec - Vef) - EDonor) - mu)) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Float64(Float64(Ev + Vef) + EAccept) + Float64(-mu)) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp((-(((Ec - Vef) - EDonor) - mu) / KbT)))) + (NaChar / (1.0 + exp(((((Ev + Vef) + EAccept) + -mu) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[((-N[(N[(N[(Ec - Vef), $MachinePrecision] - EDonor), $MachinePrecision] - mu), $MachinePrecision]) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(N[(N[(Ev + Vef), $MachinePrecision] + EAccept), $MachinePrecision] + (-mu)), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt))))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT))))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 2: 63.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_1\\ t_3 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;mu \leq -6.5 \cdot 10^{+146}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -6 \cdot 10^{+50}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.3 \cdot 10^{+17}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.3 \cdot 10^{-225}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 1.2 \cdot 10^{-39}:\\ \;\;\;\;t_3 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 7.2 \cdot 10^{+55}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 6.5 \cdot 10^{+137}:\\ \;\;\;\;t_1 + t_3\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_1))
        (t_3 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= mu -6.5e+146)
     t_2
     (if (<= mu -6e+50)
       (+
        (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
        (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
       (if (<= mu -3.3e+17)
         t_2
         (if (<= mu 1.3e-225)
           t_0
           (if (<= mu 1.2e-39)
             (+ t_3 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
             (if (<= mu 7.2e+55)
               t_0
               (if (<= mu 6.5e+137) (+ t_1 t_3) t_2)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + exp((mu / KbT)));
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_1;
	double t_3 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (mu <= -6.5e+146) {
		tmp = t_2;
	} else if (mu <= -6e+50) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (mu <= -3.3e+17) {
		tmp = t_2;
	} else if (mu <= 1.3e-225) {
		tmp = t_0;
	} else if (mu <= 1.2e-39) {
		tmp = t_3 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 7.2e+55) {
		tmp = t_0;
	} else if (mu <= 6.5e+137) {
		tmp = t_1 + t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_1
    t_3 = nachar / (1.0d0 + exp((vef / kbt)))
    if (mu <= (-6.5d+146)) then
        tmp = t_2
    else if (mu <= (-6d+50)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (mu <= (-3.3d+17)) then
        tmp = t_2
    else if (mu <= 1.3d-225) then
        tmp = t_0
    else if (mu <= 1.2d-39) then
        tmp = t_3 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 7.2d+55) then
        tmp = t_0
    else if (mu <= 6.5d+137) then
        tmp = t_1 + t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_1;
	double t_3 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (mu <= -6.5e+146) {
		tmp = t_2;
	} else if (mu <= -6e+50) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (mu <= -3.3e+17) {
		tmp = t_2;
	} else if (mu <= 1.3e-225) {
		tmp = t_0;
	} else if (mu <= 1.2e-39) {
		tmp = t_3 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 7.2e+55) {
		tmp = t_0;
	} else if (mu <= 6.5e+137) {
		tmp = t_1 + t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_1
	t_3 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if mu <= -6.5e+146:
		tmp = t_2
	elif mu <= -6e+50:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif mu <= -3.3e+17:
		tmp = t_2
	elif mu <= 1.3e-225:
		tmp = t_0
	elif mu <= 1.2e-39:
		tmp = t_3 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 7.2e+55:
		tmp = t_0
	elif mu <= 6.5e+137:
		tmp = t_1 + t_3
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_1)
	t_3 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (mu <= -6.5e+146)
		tmp = t_2;
	elseif (mu <= -6e+50)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (mu <= -3.3e+17)
		tmp = t_2;
	elseif (mu <= 1.3e-225)
		tmp = t_0;
	elseif (mu <= 1.2e-39)
		tmp = Float64(t_3 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 7.2e+55)
		tmp = t_0;
	elseif (mu <= 6.5e+137)
		tmp = Float64(t_1 + t_3);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_1 = NdChar / (1.0 + exp((mu / KbT)));
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_1;
	t_3 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (mu <= -6.5e+146)
		tmp = t_2;
	elseif (mu <= -6e+50)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (mu <= -3.3e+17)
		tmp = t_2;
	elseif (mu <= 1.3e-225)
		tmp = t_0;
	elseif (mu <= 1.2e-39)
		tmp = t_3 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 7.2e+55)
		tmp = t_0;
	elseif (mu <= 6.5e+137)
		tmp = t_1 + t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -6.5e+146], t$95$2, If[LessEqual[mu, -6e+50], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -3.3e+17], t$95$2, If[LessEqual[mu, 1.3e-225], t$95$0, If[LessEqual[mu, 1.2e-39], N[(t$95$3 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 7.2e+55], t$95$0, If[LessEqual[mu, 6.5e+137], N[(t$95$1 + t$95$3), $MachinePrecision], t$95$2]]]]]]]]]]]

Derivation

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

Alternative 3: 63.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_1\\ t_3 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;mu \leq -3.2 \cdot 10^{+93}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.25 \cdot 10^{+56}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq -6.1 \cdot 10^{+16}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 5 \cdot 10^{-223}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 2.9 \cdot 10^{-38}:\\ \;\;\;\;t_3 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 3 \cdot 10^{+56}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 6.5 \cdot 10^{+137}:\\ \;\;\;\;t_1 + t_3\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_1))
        (t_3 (/ NaChar (+ 1.0 (exp (/ Vef KbT))))))
   (if (<= mu -3.2e+93)
     t_2
     (if (<= mu -1.25e+56)
       (+
        (/ NaChar (+ 1.0 (exp (/ Ev KbT))))
        (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
       (if (<= mu -6.1e+16)
         t_2
         (if (<= mu 5e-223)
           t_0
           (if (<= mu 2.9e-38)
             (+ t_3 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
             (if (<= mu 3e+56)
               t_0
               (if (<= mu 6.5e+137) (+ t_1 t_3) t_2)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + exp((mu / KbT)));
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_1;
	double t_3 = NaChar / (1.0 + exp((Vef / KbT)));
	double tmp;
	if (mu <= -3.2e+93) {
		tmp = t_2;
	} else if (mu <= -1.25e+56) {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else if (mu <= -6.1e+16) {
		tmp = t_2;
	} else if (mu <= 5e-223) {
		tmp = t_0;
	} else if (mu <= 2.9e-38) {
		tmp = t_3 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 3e+56) {
		tmp = t_0;
	} else if (mu <= 6.5e+137) {
		tmp = t_1 + t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    t_1 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_1
    t_3 = nachar / (1.0d0 + exp((vef / kbt)))
    if (mu <= (-3.2d+93)) then
        tmp = t_2
    else if (mu <= (-1.25d+56)) then
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else if (mu <= (-6.1d+16)) then
        tmp = t_2
    else if (mu <= 5d-223) then
        tmp = t_0
    else if (mu <= 2.9d-38) then
        tmp = t_3 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 3d+56) then
        tmp = t_0
    else if (mu <= 6.5d+137) then
        tmp = t_1 + t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_1;
	double t_3 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double tmp;
	if (mu <= -3.2e+93) {
		tmp = t_2;
	} else if (mu <= -1.25e+56) {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else if (mu <= -6.1e+16) {
		tmp = t_2;
	} else if (mu <= 5e-223) {
		tmp = t_0;
	} else if (mu <= 2.9e-38) {
		tmp = t_3 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 3e+56) {
		tmp = t_0;
	} else if (mu <= 6.5e+137) {
		tmp = t_1 + t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	t_1 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_1
	t_3 = NaChar / (1.0 + math.exp((Vef / KbT)))
	tmp = 0
	if mu <= -3.2e+93:
		tmp = t_2
	elif mu <= -1.25e+56:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	elif mu <= -6.1e+16:
		tmp = t_2
	elif mu <= 5e-223:
		tmp = t_0
	elif mu <= 2.9e-38:
		tmp = t_3 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 3e+56:
		tmp = t_0
	elif mu <= 6.5e+137:
		tmp = t_1 + t_3
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_1)
	t_3 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	tmp = 0.0
	if (mu <= -3.2e+93)
		tmp = t_2;
	elseif (mu <= -1.25e+56)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	elseif (mu <= -6.1e+16)
		tmp = t_2;
	elseif (mu <= 5e-223)
		tmp = t_0;
	elseif (mu <= 2.9e-38)
		tmp = Float64(t_3 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 3e+56)
		tmp = t_0;
	elseif (mu <= 6.5e+137)
		tmp = Float64(t_1 + t_3);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	t_1 = NdChar / (1.0 + exp((mu / KbT)));
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_1;
	t_3 = NaChar / (1.0 + exp((Vef / KbT)));
	tmp = 0.0;
	if (mu <= -3.2e+93)
		tmp = t_2;
	elseif (mu <= -1.25e+56)
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / (1.0 + exp((-Ec / KbT))));
	elseif (mu <= -6.1e+16)
		tmp = t_2;
	elseif (mu <= 5e-223)
		tmp = t_0;
	elseif (mu <= 2.9e-38)
		tmp = t_3 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 3e+56)
		tmp = t_0;
	elseif (mu <= 6.5e+137)
		tmp = t_1 + t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.2e+93], t$95$2, If[LessEqual[mu, -1.25e+56], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -6.1e+16], t$95$2, If[LessEqual[mu, 5e-223], t$95$0, If[LessEqual[mu, 2.9e-38], N[(t$95$3 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3e+56], t$95$0, If[LessEqual[mu, 6.5e+137], N[(t$95$1 + t$95$3), $MachinePrecision], t$95$2]]]]]]]]]]]

Derivation

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

Alternative 4: 66.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -2.5 \cdot 10^{+145}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq -7.5 \cdot 10^{-64}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq 1.05 \cdot 10^{-225}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.2 \cdot 10^{-39}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.5 \cdot 10^{+70}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))))
   (if (<= mu -2.5e+145)
     t_0
     (if (<= mu -7.5e-64)
       t_1
       (if (<= mu 1.05e-225)
         (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
         (if (<= mu 1.2e-39)
           (+
            (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
            (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
           (if (<= mu 2.5e+70) t_1 t_0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -2.5e+145) {
		tmp = t_0;
	} else if (mu <= -7.5e-64) {
		tmp = t_1;
	} else if (mu <= 1.05e-225) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 1.2e-39) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 2.5e+70) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    t_1 = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    if (mu <= (-2.5d+145)) then
        tmp = t_0
    else if (mu <= (-7.5d-64)) then
        tmp = t_1
    else if (mu <= 1.05d-225) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else if (mu <= 1.2d-39) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 2.5d+70) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	double tmp;
	if (mu <= -2.5e+145) {
		tmp = t_0;
	} else if (mu <= -7.5e-64) {
		tmp = t_1;
	} else if (mu <= 1.05e-225) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 1.2e-39) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 2.5e+70) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	t_1 = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	tmp = 0
	if mu <= -2.5e+145:
		tmp = t_0
	elif mu <= -7.5e-64:
		tmp = t_1
	elif mu <= 1.05e-225:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	elif mu <= 1.2e-39:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 2.5e+70:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))))
	tmp = 0.0
	if (mu <= -2.5e+145)
		tmp = t_0;
	elseif (mu <= -7.5e-64)
		tmp = t_1;
	elseif (mu <= 1.05e-225)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	elseif (mu <= 1.2e-39)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 2.5e+70)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	t_1 = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	tmp = 0.0;
	if (mu <= -2.5e+145)
		tmp = t_0;
	elseif (mu <= -7.5e-64)
		tmp = t_1;
	elseif (mu <= 1.05e-225)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	elseif (mu <= 1.2e-39)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 2.5e+70)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.5e+145], t$95$0, If[LessEqual[mu, -7.5e-64], t$95$1, If[LessEqual[mu, 1.05e-225], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.2e-39], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.5e+70], t$95$1, t$95$0]]]]]]]

Derivation

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

Alternative 5: 66.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -3.3 \cdot 10^{+151}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{-64}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + t_0\\ \mathbf{elif}\;mu \leq 1.65 \cdot 10^{-225}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.95 \cdot 10^{-70}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 4 \cdot 10^{+141}:\\ \;\;\;\;t_1 + t_0\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
        (t_2
         (+
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -3.3e+151)
     t_2
     (if (<= mu -2.6e-64)
       (+ (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))) t_0)
       (if (<= mu 1.65e-225)
         (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
         (if (<= mu 1.95e-70)
           (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
           (if (<= mu 4e+141) (+ t_1 t_0) t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -3.3e+151) {
		tmp = t_2;
	} else if (mu <= -2.6e-64) {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	} else if (mu <= 1.65e-225) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 1.95e-70) {
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 4e+141) {
		tmp = t_1 + t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    t_1 = nachar / (1.0d0 + exp((vef / kbt)))
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-3.3d+151)) then
        tmp = t_2
    else if (mu <= (-2.6d-64)) then
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + t_0
    else if (mu <= 1.65d-225) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else if (mu <= 1.95d-70) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 4d+141) then
        tmp = t_1 + t_0
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -3.3e+151) {
		tmp = t_2;
	} else if (mu <= -2.6e-64) {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + t_0;
	} else if (mu <= 1.65e-225) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 1.95e-70) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 4e+141) {
		tmp = t_1 + t_0;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	t_1 = NaChar / (1.0 + math.exp((Vef / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -3.3e+151:
		tmp = t_2
	elif mu <= -2.6e-64:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + t_0
	elif mu <= 1.65e-225:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	elif mu <= 1.95e-70:
		tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 4e+141:
		tmp = t_1 + t_0
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -3.3e+151)
		tmp = t_2;
	elseif (mu <= -2.6e-64)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + t_0);
	elseif (mu <= 1.65e-225)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	elseif (mu <= 1.95e-70)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 4e+141)
		tmp = Float64(t_1 + t_0);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -3.3e+151)
		tmp = t_2;
	elseif (mu <= -2.6e-64)
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + t_0;
	elseif (mu <= 1.65e-225)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	elseif (mu <= 1.95e-70)
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 4e+141)
		tmp = t_1 + t_0;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.3e+151], t$95$2, If[LessEqual[mu, -2.6e-64], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision], If[LessEqual[mu, 1.65e-225], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.95e-70], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4e+141], N[(t$95$1 + t$95$0), $MachinePrecision], t$95$2]]]]]]]]

Derivation

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

Alternative 6: 77.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -4.7 \cdot 10^{+110}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -9 \cdot 10^{-126}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq -1.04 \cdot 10^{-240}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.9 \cdot 10^{+69}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -4.7e+110)
     t_1
     (if (<= mu -9e-126)
       t_0
       (if (<= mu -1.04e-240)
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
         (if (<= mu 2.9e+69) t_0 t_1))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -4.7e+110) {
		tmp = t_1;
	} else if (mu <= -9e-126) {
		tmp = t_0;
	} else if (mu <= -1.04e-240) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 2.9e+69) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-4.7d+110)) then
        tmp = t_1
    else if (mu <= (-9d-126)) then
        tmp = t_0
    else if (mu <= (-1.04d-240)) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else if (mu <= 2.9d+69) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -4.7e+110) {
		tmp = t_1;
	} else if (mu <= -9e-126) {
		tmp = t_0;
	} else if (mu <= -1.04e-240) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else if (mu <= 2.9e+69) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -4.7e+110:
		tmp = t_1
	elif mu <= -9e-126:
		tmp = t_0
	elif mu <= -1.04e-240:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	elif mu <= 2.9e+69:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -4.7e+110)
		tmp = t_1;
	elseif (mu <= -9e-126)
		tmp = t_0;
	elseif (mu <= -1.04e-240)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	elseif (mu <= 2.9e+69)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -4.7e+110)
		tmp = t_1;
	elseif (mu <= -9e-126)
		tmp = t_0;
	elseif (mu <= -1.04e-240)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	elseif (mu <= 2.9e+69)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.7e+110], t$95$1, If[LessEqual[mu, -9e-126], t$95$0, If[LessEqual[mu, -1.04e-240], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.9e+69], t$95$0, t$95$1]]]]]]

Derivation

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

Alternative 7: 77.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -8.2 \cdot 10^{+107}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -4.5 \cdot 10^{-244}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.6 \cdot 10^{+71}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -8.2e+107)
     t_1
     (if (<= mu -4.5e-244)
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
       (if (<= mu 1.6e+71)
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -8.2e+107) {
		tmp = t_1;
	} else if (mu <= -4.5e-244) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (mu <= 1.6e+71) {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-8.2d+107)) then
        tmp = t_1
    else if (mu <= (-4.5d-244)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (mu <= 1.6d+71) then
        tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -8.2e+107) {
		tmp = t_1;
	} else if (mu <= -4.5e-244) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (mu <= 1.6e+71) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -8.2e+107:
		tmp = t_1
	elif mu <= -4.5e-244:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif mu <= 1.6e+71:
		tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -8.2e+107)
		tmp = t_1;
	elseif (mu <= -4.5e-244)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (mu <= 1.6e+71)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -8.2e+107)
		tmp = t_1;
	elseif (mu <= -4.5e-244)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (mu <= 1.6e+71)
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -8.2e+107], t$95$1, If[LessEqual[mu, -4.5e-244], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.6e+71], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 8: 78.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -2.2 \cdot 10^{+108}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -3.5 \cdot 10^{-216}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;mu \leq 5.6 \cdot 10^{+69}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))
   (if (<= mu -2.2e+108)
     t_1
     (if (<= mu -3.5e-216)
       (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
       (if (<= mu 5.6e+69)
         (+ t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
         t_1)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	double tmp;
	if (mu <= -2.2e+108) {
		tmp = t_1;
	} else if (mu <= -3.5e-216) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if (mu <= 5.6e+69) {
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    if (mu <= (-2.2d+108)) then
        tmp = t_1
    else if (mu <= (-3.5d-216)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else if (mu <= 5.6d+69) then
        tmp = t_0 + (nachar / (1.0d0 + exp((vef / kbt))))
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	double tmp;
	if (mu <= -2.2e+108) {
		tmp = t_1;
	} else if (mu <= -3.5e-216) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if (mu <= 5.6e+69) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Vef / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	tmp = 0
	if mu <= -2.2e+108:
		tmp = t_1
	elif mu <= -3.5e-216:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif mu <= 5.6e+69:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Vef / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))))
	tmp = 0.0
	if (mu <= -2.2e+108)
		tmp = t_1;
	elseif (mu <= -3.5e-216)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif (mu <= 5.6e+69)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	tmp = 0.0;
	if (mu <= -2.2e+108)
		tmp = t_1;
	elseif (mu <= -3.5e-216)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif (mu <= 5.6e+69)
		tmp = t_0 + (NaChar / (1.0 + exp((Vef / KbT))));
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.2e+108], t$95$1, If[LessEqual[mu, -3.5e-216], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 5.6e+69], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 9: 63.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}} + t_0\\ t_3 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -1.18 \cdot 10^{+17}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 2.4 \cdot 10^{-225}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{-34}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 1.9 \cdot 10^{+57}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 1.22 \cdot 10^{+141}:\\ \;\;\;\;t_0 + t_1\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
        (t_2 (+ (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))) t_0))
        (t_3 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= mu -1.18e+17)
     t_2
     (if (<= mu 2.4e-225)
       t_3
       (if (<= mu 4.8e-34)
         (+ t_1 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (if (<= mu 1.9e+57) t_3 (if (<= mu 1.22e+141) (+ t_0 t_1) t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((mu / KbT)));
	double t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	double t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	double t_3 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -1.18e+17) {
		tmp = t_2;
	} else if (mu <= 2.4e-225) {
		tmp = t_3;
	} else if (mu <= 4.8e-34) {
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 1.9e+57) {
		tmp = t_3;
	} else if (mu <= 1.22e+141) {
		tmp = t_0 + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_1 = nachar / (1.0d0 + exp((vef / kbt)))
    t_2 = (nachar / (1.0d0 + exp((-mu / kbt)))) + t_0
    t_3 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (mu <= (-1.18d+17)) then
        tmp = t_2
    else if (mu <= 2.4d-225) then
        tmp = t_3
    else if (mu <= 4.8d-34) then
        tmp = t_1 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 1.9d+57) then
        tmp = t_3
    else if (mu <= 1.22d+141) then
        tmp = t_0 + t_1
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double t_2 = (NaChar / (1.0 + Math.exp((-mu / KbT)))) + t_0;
	double t_3 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -1.18e+17) {
		tmp = t_2;
	} else if (mu <= 2.4e-225) {
		tmp = t_3;
	} else if (mu <= 4.8e-34) {
		tmp = t_1 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 1.9e+57) {
		tmp = t_3;
	} else if (mu <= 1.22e+141) {
		tmp = t_0 + t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_1 = NaChar / (1.0 + math.exp((Vef / KbT)))
	t_2 = (NaChar / (1.0 + math.exp((-mu / KbT)))) + t_0
	t_3 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if mu <= -1.18e+17:
		tmp = t_2
	elif mu <= 2.4e-225:
		tmp = t_3
	elif mu <= 4.8e-34:
		tmp = t_1 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 1.9e+57:
		tmp = t_3
	elif mu <= 1.22e+141:
		tmp = t_0 + t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	t_2 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))) + t_0)
	t_3 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (mu <= -1.18e+17)
		tmp = t_2;
	elseif (mu <= 2.4e-225)
		tmp = t_3;
	elseif (mu <= 4.8e-34)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 1.9e+57)
		tmp = t_3;
	elseif (mu <= 1.22e+141)
		tmp = Float64(t_0 + t_1);
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((mu / KbT)));
	t_1 = NaChar / (1.0 + exp((Vef / KbT)));
	t_2 = (NaChar / (1.0 + exp((-mu / KbT)))) + t_0;
	t_3 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (mu <= -1.18e+17)
		tmp = t_2;
	elseif (mu <= 2.4e-225)
		tmp = t_3;
	elseif (mu <= 4.8e-34)
		tmp = t_1 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 1.9e+57)
		tmp = t_3;
	elseif (mu <= 1.22e+141)
		tmp = t_0 + t_1;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]}, Block[{t$95$3 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -1.18e+17], t$95$2, If[LessEqual[mu, 2.4e-225], t$95$3, If[LessEqual[mu, 4.8e-34], N[(t$95$1 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.9e+57], t$95$3, If[LessEqual[mu, 1.22e+141], N[(t$95$0 + t$95$1), $MachinePrecision], t$95$2]]]]]]]]]

Derivation

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

Alternative 10: 56.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -4.2 \cdot 10^{+14}:\\ \;\;\;\;t_1 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.9 \cdot 10^{-227}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.28 \cdot 10^{-36}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.8 \cdot 10^{+56}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 3.4 \cdot 10^{+139}:\\ \;\;\;\;t_1 + t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ Vef KbT)))))
        (t_1 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
        (t_2 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= mu -4.2e+14)
     (+ t_1 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
     (if (<= mu 2.9e-227)
       t_2
       (if (<= mu 1.28e-36)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (if (<= mu 3.8e+56)
           t_2
           (if (<= mu 3.4e+139)
             (+ t_1 t_0)
             (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_1))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	double t_1 = NdChar / (1.0 + exp((mu / KbT)));
	double t_2 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -4.2e+14) {
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (mu <= 2.9e-227) {
		tmp = t_2;
	} else if (mu <= 1.28e-36) {
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else if (mu <= 3.8e+56) {
		tmp = t_2;
	} else if (mu <= 3.4e+139) {
		tmp = t_1 + t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_1;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp((vef / kbt)))
    t_1 = ndchar / (1.0d0 + exp((mu / kbt)))
    t_2 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (mu <= (-4.2d+14)) then
        tmp = t_1 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (mu <= 2.9d-227) then
        tmp = t_2
    else if (mu <= 1.28d-36) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else if (mu <= 3.8d+56) then
        tmp = t_2
    else if (mu <= 3.4d+139) then
        tmp = t_1 + t_0
    else
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_1
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp((Vef / KbT)));
	double t_1 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double t_2 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -4.2e+14) {
		tmp = t_1 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (mu <= 2.9e-227) {
		tmp = t_2;
	} else if (mu <= 1.28e-36) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else if (mu <= 3.8e+56) {
		tmp = t_2;
	} else if (mu <= 3.4e+139) {
		tmp = t_1 + t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp((Vef / KbT)))
	t_1 = NdChar / (1.0 + math.exp((mu / KbT)))
	t_2 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if mu <= -4.2e+14:
		tmp = t_1 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif mu <= 2.9e-227:
		tmp = t_2
	elif mu <= 1.28e-36:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 3.8e+56:
		tmp = t_2
	elif mu <= 3.4e+139:
		tmp = t_1 + t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT))))
	t_1 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	t_2 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (mu <= -4.2e+14)
		tmp = Float64(t_1 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (mu <= 2.9e-227)
		tmp = t_2;
	elseif (mu <= 1.28e-36)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 3.8e+56)
		tmp = t_2;
	elseif (mu <= 3.4e+139)
		tmp = Float64(t_1 + t_0);
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_1);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp((Vef / KbT)));
	t_1 = NdChar / (1.0 + exp((mu / KbT)));
	t_2 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (mu <= -4.2e+14)
		tmp = t_1 + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (mu <= 2.9e-227)
		tmp = t_2;
	elseif (mu <= 1.28e-36)
		tmp = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 3.8e+56)
		tmp = t_2;
	elseif (mu <= 3.4e+139)
		tmp = t_1 + t_0;
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.2e+14], N[(t$95$1 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.9e-227], t$95$2, If[LessEqual[mu, 1.28e-36], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.8e+56], t$95$2, If[LessEqual[mu, 3.4e+139], N[(t$95$1 + t$95$0), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]]]

Derivation

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

Alternative 11: 76.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -8.6 \cdot 10^{+96} \lor \neg \left(Vef \leq 9.2 \cdot 10^{+57}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Vef -8.6e+96) (not (<= Vef 9.2e+57)))
   (+
    (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
    (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT)))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar (+ 1.0 (exp (/ mu KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -8.6e+96) || !(Vef <= 9.2e+57)) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((vef <= (-8.6d+96)) .or. (.not. (vef <= 9.2d+57))) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt))))
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp((mu / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((Vef <= -8.6e+96) || !(Vef <= 9.2e+57)) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT))));
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((mu / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (Vef <= -8.6e+96) or not (Vef <= 9.2e+57):
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT))))
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + math.exp((mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((Vef <= -8.6e+96) || !(Vef <= 9.2e+57))
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((Vef <= -8.6e+96) || ~((Vef <= 9.2e+57)))
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT))));
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp((mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Vef, -8.6e+96], N[Not[LessEqual[Vef, 9.2e+57]], $MachinePrecision]], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 12: 74.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}}\\ \mathbf{if}\;Ev \leq -1.3 \cdot 10^{+129}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))))
   (if (<= Ev -1.3e+129)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -1.3e+129) {
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))
    if (ev <= (-1.3d+129)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((ev / kbt))))
    else
        tmp = t_0 + (nachar / (1.0d0 + exp((-mu / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	double tmp;
	if (Ev <= -1.3e+129) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))
	tmp = 0
	if Ev <= -1.3e+129:
		tmp = t_0 + (NaChar / (1.0 + math.exp((Ev / KbT))))
	else:
		tmp = t_0 + (NaChar / (1.0 + math.exp((-mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))
	tmp = 0.0
	if (Ev <= -1.3e+129)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	else
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)));
	tmp = 0.0;
	if (Ev <= -1.3e+129)
		tmp = t_0 + (NaChar / (1.0 + exp((Ev / KbT))));
	else
		tmp = t_0 + (NaChar / (1.0 + exp((-mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ev, -1.3e+129], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 13: 60.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -5.5 \cdot 10^{-17} \lor \neg \left(NdChar \leq 1.1 \cdot 10^{-243}\right) \land \left(NdChar \leq 3.3 \cdot 10^{-214} \lor \neg \left(NdChar \leq 3.2 \cdot 10^{-81}\right)\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -5.5e-17)
         (and (not (<= NdChar 1.1e-243))
              (or (<= NdChar 3.3e-214) (not (<= NdChar 3.2e-81)))))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
    (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -5.5e-17) || (!(NdChar <= 1.1e-243) && ((NdChar <= 3.3e-214) || !(NdChar <= 3.2e-81)))) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((ndchar <= (-5.5d-17)) .or. (.not. (ndchar <= 1.1d-243)) .and. (ndchar <= 3.3d-214) .or. (.not. (ndchar <= 3.2d-81))) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((eaccept / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -5.5e-17) || (!(NdChar <= 1.1e-243) && ((NdChar <= 3.3e-214) || !(NdChar <= 3.2e-81)))) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((EAccept / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -5.5e-17) or (not (NdChar <= 1.1e-243) and ((NdChar <= 3.3e-214) or not (NdChar <= 3.2e-81))):
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp((EAccept / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -5.5e-17) || (!(NdChar <= 1.1e-243) && ((NdChar <= 3.3e-214) || !(NdChar <= 3.2e-81))))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -5.5e-17) || (~((NdChar <= 1.1e-243)) && ((NdChar <= 3.3e-214) || ~((NdChar <= 3.2e-81)))))
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((EAccept / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -5.5e-17], And[N[Not[LessEqual[NdChar, 1.1e-243]], $MachinePrecision], Or[LessEqual[NdChar, 3.3e-214], N[Not[LessEqual[NdChar, 3.2e-81]], $MachinePrecision]]]], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 14: 56.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -3.9 \cdot 10^{+175}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq -2.4 \cdot 10^{+17}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.8 \cdot 10^{-226} \lor \neg \left(mu \leq 1.22 \cdot 10^{-30}\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= mu -3.9e+175)
     t_0
     (if (<= mu -2.4e+17)
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
       (if (or (<= mu 3.8e-226) (not (<= mu 1.22e-30)))
         t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -3.9e+175) {
		tmp = t_0;
	} else if (mu <= -2.4e+17) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if ((mu <= 3.8e-226) || !(mu <= 1.22e-30)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (mu <= (-3.9d+175)) then
        tmp = t_0
    else if (mu <= (-2.4d+17)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if ((mu <= 3.8d-226) .or. (.not. (mu <= 1.22d-30))) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (mu <= -3.9e+175) {
		tmp = t_0;
	} else if (mu <= -2.4e+17) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if ((mu <= 3.8e-226) || !(mu <= 1.22e-30)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if mu <= -3.9e+175:
		tmp = t_0
	elif mu <= -2.4e+17:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif (mu <= 3.8e-226) or not (mu <= 1.22e-30):
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (mu <= -3.9e+175)
		tmp = t_0;
	elseif (mu <= -2.4e+17)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif ((mu <= 3.8e-226) || !(mu <= 1.22e-30))
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (mu <= -3.9e+175)
		tmp = t_0;
	elseif (mu <= -2.4e+17)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif ((mu <= 3.8e-226) || ~((mu <= 1.22e-30)))
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -3.9e+175], t$95$0, If[LessEqual[mu, -2.4e+17], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[mu, 3.8e-226], N[Not[LessEqual[mu, 1.22e-30]], $MachinePrecision]], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 15: 58.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;mu \leq -2.2 \cdot 10^{+17}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq 5.4 \cdot 10^{-223} \lor \neg \left(mu \leq 8.4 \cdot 10^{-36}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= mu -2.2e+17)
   (+
    (/ NdChar (+ 1.0 (exp (/ mu KbT))))
    (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
   (if (or (<= mu 5.4e-223) (not (<= mu 8.4e-36)))
     (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
     (+
      (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
      (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (mu <= -2.2e+17) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if ((mu <= 5.4e-223) || !(mu <= 8.4e-36)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (mu <= (-2.2d+17)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if ((mu <= 5.4d-223) .or. (.not. (mu <= 8.4d-36))) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (mu <= -2.2e+17) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if ((mu <= 5.4e-223) || !(mu <= 8.4e-36)) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if mu <= -2.2e+17:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif (mu <= 5.4e-223) or not (mu <= 8.4e-36):
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (mu <= -2.2e+17)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif ((mu <= 5.4e-223) || !(mu <= 8.4e-36))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (mu <= -2.2e+17)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif ((mu <= 5.4e-223) || ~((mu <= 8.4e-36)))
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[mu, -2.2e+17], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[mu, 5.4e-223], N[Not[LessEqual[mu, 8.4e-36]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 16: 55.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{if}\;mu \leq -2750000000000:\\ \;\;\;\;t_0 + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq 3.8 \cdot 10^{-224}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{-9}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT))))))
   (if (<= mu -2750000000000.0)
     (+ t_0 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
     (if (<= mu 3.8e-224)
       (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
       (if (<= mu 2.6e-9)
         (+
          (/ NaChar (+ 1.0 (exp (/ Vef KbT))))
          (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))
         (+ (/ NaChar (+ 1.0 (exp (/ Ev KbT)))) t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((mu / KbT)));
	double tmp;
	if (mu <= -2750000000000.0) {
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (mu <= 3.8e-224) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 2.6e-9) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((mu / kbt)))
    if (mu <= (-2750000000000.0d0)) then
        tmp = t_0 + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (mu <= 3.8d-224) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else if (mu <= 2.6d-9) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / (1.0d0 + exp((edonor / kbt))))
    else
        tmp = (nachar / (1.0d0 + exp((ev / kbt)))) + t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((mu / KbT)));
	double tmp;
	if (mu <= -2750000000000.0) {
		tmp = t_0 + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (mu <= 3.8e-224) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else if (mu <= 2.6e-9) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((mu / KbT)))
	tmp = 0
	if mu <= -2750000000000.0:
		tmp = t_0 + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif mu <= 3.8e-224:
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	elif mu <= 2.6e-9:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	else:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT))))
	tmp = 0.0
	if (mu <= -2750000000000.0)
		tmp = Float64(t_0 + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (mu <= 3.8e-224)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	elseif (mu <= 2.6e-9)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))) + t_0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((mu / KbT)));
	tmp = 0.0;
	if (mu <= -2750000000000.0)
		tmp = t_0 + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (mu <= 3.8e-224)
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	elseif (mu <= 2.6e-9)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2750000000000.0], N[(t$95$0 + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.8e-224], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.6e-9], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$0), $MachinePrecision]]]]]

Derivation

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

Alternative 17: 58.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{if}\;NdChar \leq -5.6 \cdot 10^{-45}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq -1.1 \cdot 10^{-166}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NdChar \leq -2.25 \cdot 10^{-242}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{elif}\;NdChar \leq 6.2 \cdot 10^{-260}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))))
   (if (<= NdChar -5.6e-45)
     t_0
     (if (<= NdChar -1.1e-166)
       (+
        (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
        (/ NaChar 2.0))
       (if (<= NdChar -2.25e-242)
         (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))
         (if (<= NdChar 6.2e-260)
           (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0))
           t_0))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (NdChar <= -5.6e-45) {
		tmp = t_0;
	} else if (NdChar <= -1.1e-166) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	} else if (NdChar <= -2.25e-242) {
		tmp = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	} else if (NdChar <= 6.2e-260) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    if (ndchar <= (-5.6d-45)) then
        tmp = t_0
    else if (ndchar <= (-1.1d-166)) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar / 2.0d0)
    else if (ndchar <= (-2.25d-242)) then
        tmp = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    else if (ndchar <= 6.2d-260) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	double tmp;
	if (NdChar <= -5.6e-45) {
		tmp = t_0;
	} else if (NdChar <= -1.1e-166) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	} else if (NdChar <= -2.25e-242) {
		tmp = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	} else if (NdChar <= 6.2e-260) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	tmp = 0
	if NdChar <= -5.6e-45:
		tmp = t_0
	elif NdChar <= -1.1e-166:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0)
	elif NdChar <= -2.25e-242:
		tmp = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	elif NdChar <= 6.2e-260:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0)
	else:
		tmp = t_0
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))))
	tmp = 0.0
	if (NdChar <= -5.6e-45)
		tmp = t_0;
	elseif (NdChar <= -1.1e-166)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar / 2.0));
	elseif (NdChar <= -2.25e-242)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))));
	elseif (NdChar <= 6.2e-260)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	tmp = 0.0;
	if (NdChar <= -5.6e-45)
		tmp = t_0;
	elseif (NdChar <= -1.1e-166)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar / 2.0);
	elseif (NdChar <= -2.25e-242)
		tmp = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	elseif (NdChar <= 6.2e-260)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -5.6e-45], t$95$0, If[LessEqual[NdChar, -1.1e-166], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.25e-242], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 6.2e-260], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], t$95$0]]]]]

Derivation

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

Alternative 18: 40.6% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.2 \cdot 10^{-68} \lor \neg \left(NaChar \leq -8.5 \cdot 10^{-212} \lor \neg \left(NaChar \leq -1.9 \cdot 10^{-260}\right) \land NaChar \leq 1.85 \cdot 10^{-25}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -1.2e-68)
         (not
          (or (<= NaChar -8.5e-212)
              (and (not (<= NaChar -1.9e-260)) (<= NaChar 1.85e-25)))))
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.2e-68) || !((NaChar <= -8.5e-212) || (!(NaChar <= -1.9e-260) && (NaChar <= 1.85e-25)))) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((nachar <= (-1.2d-68)) .or. (.not. (nachar <= (-8.5d-212)) .or. (.not. (nachar <= (-1.9d-260))) .and. (nachar <= 1.85d-25))) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NaChar <= -1.2e-68) || !((NaChar <= -8.5e-212) || (!(NaChar <= -1.9e-260) && (NaChar <= 1.85e-25)))) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NaChar <= -1.2e-68) or not ((NaChar <= -8.5e-212) or (not (NaChar <= -1.9e-260) and (NaChar <= 1.85e-25))):
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	else:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NaChar <= -1.2e-68) || !((NaChar <= -8.5e-212) || (!(NaChar <= -1.9e-260) && (NaChar <= 1.85e-25))))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NaChar <= -1.2e-68) || ~(((NaChar <= -8.5e-212) || (~((NaChar <= -1.9e-260)) && (NaChar <= 1.85e-25)))))
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	else
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -1.2e-68], N[Not[Or[LessEqual[NaChar, -8.5e-212], And[N[Not[LessEqual[NaChar, -1.9e-260]], $MachinePrecision], LessEqual[NaChar, 1.85e-25]]]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 19: 49.2% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{\left(mu + Vef\right) - Ec}{KbT}}}\\ \mathbf{if}\;mu \leq -2.7 \cdot 10^{+175}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq -23000000000000:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;mu \leq 2.6 \cdot 10^{-222} \lor \neg \left(mu \leq 6.4 \cdot 10^{-37}\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NdChar (+ 1.0 (exp (/ (- (+ mu Vef) Ec) KbT))))))
   (if (<= mu -2.7e+175)
     t_0
     (if (<= mu -23000000000000.0)
       (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
       (if (or (<= mu 2.6e-222) (not (<= mu 6.4e-37)))
         t_0
         (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	double tmp;
	if (mu <= -2.7e+175) {
		tmp = t_0;
	} else if (mu <= -23000000000000.0) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else if ((mu <= 2.6e-222) || !(mu <= 6.4e-37)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = ndchar / (1.0d0 + exp((((mu + vef) - ec) / kbt)))
    if (mu <= (-2.7d+175)) then
        tmp = t_0
    else if (mu <= (-23000000000000.0d0)) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else if ((mu <= 2.6d-222) .or. (.not. (mu <= 6.4d-37))) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NdChar / (1.0 + Math.exp((((mu + Vef) - Ec) / KbT)));
	double tmp;
	if (mu <= -2.7e+175) {
		tmp = t_0;
	} else if (mu <= -23000000000000.0) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else if ((mu <= 2.6e-222) || !(mu <= 6.4e-37)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NdChar / (1.0 + math.exp((((mu + Vef) - Ec) / KbT)))
	tmp = 0
	if mu <= -2.7e+175:
		tmp = t_0
	elif mu <= -23000000000000.0:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	elif (mu <= 2.6e-222) or not (mu <= 6.4e-37):
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(mu + Vef) - Ec) / KbT))))
	tmp = 0.0
	if (mu <= -2.7e+175)
		tmp = t_0;
	elseif (mu <= -23000000000000.0)
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	elseif ((mu <= 2.6e-222) || !(mu <= 6.4e-37))
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NdChar / (1.0 + exp((((mu + Vef) - Ec) / KbT)));
	tmp = 0.0;
	if (mu <= -2.7e+175)
		tmp = t_0;
	elseif (mu <= -23000000000000.0)
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	elseif ((mu <= 2.6e-222) || ~((mu <= 6.4e-37)))
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(mu + Vef), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -2.7e+175], t$95$0, If[LessEqual[mu, -23000000000000.0], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[mu, 2.6e-222], N[Not[LessEqual[mu, 6.4e-37]], $MachinePrecision]], t$95$0, N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 20: 38.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{if}\;EAccept \leq 1.4 \cdot 10^{-136}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;EAccept \leq 0.009:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{elif}\;EAccept \leq 2.95 \cdot 10^{+84}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ (/ NdChar (+ 1.0 (exp (/ mu KbT)))) (/ NaChar 2.0))))
   (if (<= EAccept 1.4e-136)
     t_0
     (if (<= EAccept 0.009)
       (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0))
       (if (<= EAccept 2.95e+84)
         t_0
         (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	double tmp;
	if (EAccept <= 1.4e-136) {
		tmp = t_0;
	} else if (EAccept <= 0.009) {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 2.95e+84) {
		tmp = t_0;
	} else {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / 2.0d0)
    if (eaccept <= 1.4d-136) then
        tmp = t_0
    else if (eaccept <= 0.009d0) then
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
    else if (eaccept <= 2.95d+84) then
        tmp = t_0
    else
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / 2.0);
	double tmp;
	if (EAccept <= 1.4e-136) {
		tmp = t_0;
	} else if (EAccept <= 0.009) {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
	} else if (EAccept <= 2.95e+84) {
		tmp = t_0;
	} else {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / 2.0)
	tmp = 0
	if EAccept <= 1.4e-136:
		tmp = t_0
	elif EAccept <= 0.009:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0)
	elif EAccept <= 2.95e+84:
		tmp = t_0
	else:
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / 2.0))
	tmp = 0.0
	if (EAccept <= 1.4e-136)
		tmp = t_0;
	elseif (EAccept <= 0.009)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0));
	elseif (EAccept <= 2.95e+84)
		tmp = t_0;
	else
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / 2.0);
	tmp = 0.0;
	if (EAccept <= 1.4e-136)
		tmp = t_0;
	elseif (EAccept <= 0.009)
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	elseif (EAccept <= 2.95e+84)
		tmp = t_0;
	else
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EAccept, 1.4e-136], t$95$0, If[LessEqual[EAccept, 0.009], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[EAccept, 2.95e+84], t$95$0, N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 21: 60.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.25 \cdot 10^{-242} \lor \neg \left(NdChar \leq 6.3 \cdot 10^{-260}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -2.25e-242) (not (<= NdChar 6.3e-260)))
   (/ NdChar (+ 1.0 (exp (/ (- (+ EDonor (+ mu Vef)) Ec) KbT))))
   (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2.25e-242) || !(NdChar <= 6.3e-260)) {
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((ndchar <= (-2.25d-242)) .or. (.not. (ndchar <= 6.3d-260))) then
        tmp = ndchar / (1.0d0 + exp((((edonor + (mu + vef)) - ec) / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((NdChar <= -2.25e-242) || !(NdChar <= 6.3e-260)) {
		tmp = NdChar / (1.0 + Math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -2.25e-242) or not (NdChar <= 6.3e-260):
		tmp = NdChar / (1.0 + math.exp((((EDonor + (mu + Vef)) - Ec) / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -2.25e-242) || !(NdChar <= 6.3e-260))
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -2.25e-242) || ~((NdChar <= 6.3e-260)))
		tmp = NdChar / (1.0 + exp((((EDonor + (mu + Vef)) - Ec) / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.25e-242], N[Not[LessEqual[NdChar, 6.3e-260]], $MachinePrecision]], N[(NdChar / N[(1.0 + N[Exp[N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 22: 40.5% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;EAccept \leq -2.6 \cdot 10^{-36} \lor \neg \left(EAccept \leq 3.2 \cdot 10^{+46}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= EAccept -2.6e-36) (not (<= EAccept 3.2e+46)))
   (/ NaChar (+ 1.0 (exp (/ EAccept KbT))))
   (+ (/ NaChar (+ 1.0 (exp (/ Vef KbT)))) (/ NdChar 2.0))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((EAccept <= -2.6e-36) || !(EAccept <= 3.2e+46)) {
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((eaccept <= (-2.6d-36)) .or. (.not. (eaccept <= 3.2d+46))) then
        tmp = nachar / (1.0d0 + exp((eaccept / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((vef / kbt)))) + (ndchar / 2.0d0)
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((EAccept <= -2.6e-36) || !(EAccept <= 3.2e+46)) {
		tmp = NaChar / (1.0 + Math.exp((EAccept / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Vef / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (EAccept <= -2.6e-36) or not (EAccept <= 3.2e+46):
		tmp = NaChar / (1.0 + math.exp((EAccept / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp((Vef / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((EAccept <= -2.6e-36) || !(EAccept <= 3.2e+46))
		tmp = Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NdChar / 2.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((EAccept <= -2.6e-36) || ~((EAccept <= 3.2e+46)))
		tmp = NaChar / (1.0 + exp((EAccept / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((Vef / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[EAccept, -2.6e-36], N[Not[LessEqual[EAccept, 3.2e+46]], $MachinePrecision]], N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 23: 35.4% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return NaChar / (1.0 + exp((EAccept / KbT)));
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = nachar / (1.0d0 + exp((eaccept / kbt)))
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return NaChar / (1.0 + Math.exp((EAccept / KbT)));
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return NaChar / (1.0 + math.exp((EAccept / KbT)))

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT))))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = NaChar / (1.0 + exp((EAccept / KbT)));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 24: 31.2% accurate, 15.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -9.2 \cdot 10^{+45} \lor \neg \left(KbT \leq 2 \cdot 10^{-146}\right):\\ \;\;\;\;0.5 \cdot \left(NdChar + NaChar\right)\\ \mathbf{else}:\\ \;\;\;\;NaChar \cdot \frac{KbT}{EAccept + \left(Ev + \left(Vef - mu\right)\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -9.2e+45) (not (<= KbT 2e-146)))
   (* 0.5 (+ NdChar NaChar))
   (* NaChar (/ KbT (+ EAccept (+ Ev (- Vef mu)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.2e+45) || !(KbT <= 2e-146)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar * (KbT / (EAccept + (Ev + (Vef - mu))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if ((kbt <= (-9.2d+45)) .or. (.not. (kbt <= 2d-146))) then
        tmp = 0.5d0 * (ndchar + nachar)
    else
        tmp = nachar * (kbt / (eaccept + (ev + (vef - mu))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if ((KbT <= -9.2e+45) || !(KbT <= 2e-146)) {
		tmp = 0.5 * (NdChar + NaChar);
	} else {
		tmp = NaChar * (KbT / (EAccept + (Ev + (Vef - mu))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -9.2e+45) or not (KbT <= 2e-146):
		tmp = 0.5 * (NdChar + NaChar)
	else:
		tmp = NaChar * (KbT / (EAccept + (Ev + (Vef - mu))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -9.2e+45) || !(KbT <= 2e-146))
		tmp = Float64(0.5 * Float64(NdChar + NaChar));
	else
		tmp = Float64(NaChar * Float64(KbT / Float64(EAccept + Float64(Ev + Float64(Vef - mu)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -9.2e+45) || ~((KbT <= 2e-146)))
		tmp = 0.5 * (NdChar + NaChar);
	else
		tmp = NaChar * (KbT / (EAccept + (Ev + (Vef - mu))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -9.2e+45], N[Not[LessEqual[KbT, 2e-146]], $MachinePrecision]], N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision], N[(NaChar * N[(KbT / N[(EAccept + N[(Ev + N[(Vef - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 25: 28.0% accurate, 45.8× speedup

Math

\[\begin{array}{l} \\ 0.5 \cdot \left(NdChar + NaChar\right) \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (* 0.5 (+ NdChar NaChar)))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return 0.5 * (NdChar + NaChar);
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    code = 0.5d0 * (ndchar + nachar)
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	return 0.5 * (NdChar + NaChar);
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	return 0.5 * (NdChar + NaChar)

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(0.5 * Float64(NdChar + NaChar))
end

MATLAB

function tmp = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.5 * (NdChar + NaChar);
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(0.5 * N[(NdChar + NaChar), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2024008 
(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
  :name "Bulmash initializePoisson"
  :precision binary64
  (+ (/ NdChar (+ 1.0 (exp (/ (- (- (- (- Ec Vef) EDonor) mu)) KbT)))) (/ NaChar (+ 1.0 (exp (/ (+ (+ (+ Ev Vef) EAccept) (- mu)) KbT))))))