Bulmash initializePoisson

Percentage Accurate: 99.9% → 99.9%

Time: 29.9s

Alternatives: 23

Speedup: 1.0×

• could not determine a ground truth

  1. NdChar = 3.476776229551208e-42
  2. Ec = -2.842098960369468e+260
  3. Vef = 2.320792084793746e-216
  4. EDonor = 5.618975055187872e-177
  5. mu = 3.275288027925777e-260
  6. KbT = -3.620755633400189e+229
  7. NaChar = 7.941219909071157e-43
  8. Ev = 2.1155947298796003e+300
  9. EAccept = 1.1771262333723862e-164

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: 99.9% 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: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ NdChar \cdot \frac{1}{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 (+ 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 / (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 / (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 / (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 / (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 / 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 / (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[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $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: 77.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_2 := t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -2.6 \cdot 10^{+70}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;EDonor \leq -1.3 \cdot 10^{-88}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;EDonor \leq -2.3 \cdot 10^{-118}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 3.8 \cdot 10^{-7}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
        (t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -2.6e+70)
     t_2
     (if (<= EDonor -1.3e-88)
       t_1
       (if (<= EDonor -2.3e-118)
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT)))))
         (if (<= EDonor 3.8e-7) 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -2.6e+70) {
		tmp = t_2;
	} else if (EDonor <= -1.3e-88) {
		tmp = t_1;
	} else if (EDonor <= -2.3e-118) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	} else if (EDonor <= 3.8e-7) {
		tmp = 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) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    t_2 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-2.6d+70)) then
        tmp = t_2
    else if (edonor <= (-1.3d-88)) then
        tmp = t_1
    else if (edonor <= (-2.3d-118)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    else if (edonor <= 3.8d-7) then
        tmp = 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -2.6e+70) {
		tmp = t_2;
	} else if (EDonor <= -1.3e-88) {
		tmp = t_1;
	} else if (EDonor <= -2.3e-118) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	} else if (EDonor <= 3.8e-7) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	t_2 = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -2.6e+70:
		tmp = t_2
	elif EDonor <= -1.3e-88:
		tmp = t_1
	elif EDonor <= -2.3e-118:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	elif EDonor <= 3.8e-7:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -2.6e+70)
		tmp = t_2;
	elseif (EDonor <= -1.3e-88)
		tmp = t_1;
	elseif (EDonor <= -2.3e-118)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))));
	elseif (EDonor <= 3.8e-7)
		tmp = 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -2.6e+70)
		tmp = t_2;
	elseif (EDonor <= -1.3e-88)
		tmp = t_1;
	elseif (EDonor <= -2.3e-118)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	elseif (EDonor <= 3.8e-7)
		tmp = 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -2.6e+70], t$95$2, If[LessEqual[EDonor, -1.3e-88], t$95$1, If[LessEqual[EDonor, -2.3e-118], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[((-mu) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 3.8e-7], t$95$1, t$95$2]]]]]]]

Derivation

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

Alternative 3: 77.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_2 := t_0 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ \mathbf{if}\;EDonor \leq -9.2 \cdot 10^{+75}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;EDonor \leq -3.7 \cdot 10^{-72}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;EDonor \leq 2.65 \cdot 10^{-265}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{elif}\;EDonor \leq 4.3 \cdot 10^{-7}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ 1.0 (exp (/ Vef KbT))))))
        (t_2 (+ t_0 (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))))))
   (if (<= EDonor -9.2e+75)
     t_2
     (if (<= EDonor -3.7e-72)
       t_1
       (if (<= EDonor 2.65e-265)
         (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
         (if (<= EDonor 4.3e-7) 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -9.2e+75) {
		tmp = t_2;
	} else if (EDonor <= -3.7e-72) {
		tmp = t_1;
	} else if (EDonor <= 2.65e-265) {
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	} else if (EDonor <= 4.3e-7) {
		tmp = 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) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / (1.0d0 + exp((vef / kbt))))
    t_2 = t_0 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    if (edonor <= (-9.2d+75)) then
        tmp = t_2
    else if (edonor <= (-3.7d-72)) then
        tmp = t_1
    else if (edonor <= 2.65d-265) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    else if (edonor <= 4.3d-7) then
        tmp = 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double t_2 = t_0 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double tmp;
	if (EDonor <= -9.2e+75) {
		tmp = t_2;
	} else if (EDonor <= -3.7e-72) {
		tmp = t_1;
	} else if (EDonor <= 2.65e-265) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else if (EDonor <= 4.3e-7) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	t_2 = t_0 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	tmp = 0
	if EDonor <= -9.2e+75:
		tmp = t_2
	elif EDonor <= -3.7e-72:
		tmp = t_1
	elif EDonor <= 2.65e-265:
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	elif EDonor <= 4.3e-7:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	tmp = 0.0
	if (EDonor <= -9.2e+75)
		tmp = t_2;
	elseif (EDonor <= -3.7e-72)
		tmp = t_1;
	elseif (EDonor <= 2.65e-265)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	elseif (EDonor <= 4.3e-7)
		tmp = 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / (1.0 + exp((Vef / KbT))));
	t_2 = t_0 + (NdChar / (1.0 + exp((EDonor / KbT))));
	tmp = 0.0;
	if (EDonor <= -9.2e+75)
		tmp = t_2;
	elseif (EDonor <= -3.7e-72)
		tmp = t_1;
	elseif (EDonor <= 2.65e-265)
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	elseif (EDonor <= 4.3e-7)
		tmp = 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[EDonor, -9.2e+75], t$95$2, If[LessEqual[EDonor, -3.7e-72], t$95$1, If[LessEqual[EDonor, 2.65e-265], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[EDonor, 4.3e-7], t$95$1, t$95$2]]]]]]]

Derivation

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

Alternative 4: 99.9% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (+
  (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
  (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) 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(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / 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(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / 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(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))));
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := 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[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 5: 77.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ \mathbf{if}\;Ec \leq -2.7 \cdot 10^{+19} \lor \neg \left(Ec \leq 4.9 \cdot 10^{+33}\right):\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \frac{NdChar}{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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))))
   (if (or (<= Ec -2.7e+19) (not (<= Ec 4.9e+33)))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))))
     (+ t_0 (/ 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 t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if ((Ec <= -2.7e+19) || !(Ec <= 4.9e+33)) {
		tmp = t_0 + (NdChar / (1.0 + exp((-Ec / KbT))));
	} else {
		tmp = t_0 + (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) :: t_0
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    if ((ec <= (-2.7d+19)) .or. (.not. (ec <= 4.9d+33))) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((-ec / kbt))))
    else
        tmp = t_0 + (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 t_0 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if ((Ec <= -2.7e+19) || !(Ec <= 4.9e+33)) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((-Ec / KbT))));
	} else {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	tmp = 0
	if (Ec <= -2.7e+19) or not (Ec <= 4.9e+33):
		tmp = t_0 + (NdChar / (1.0 + math.exp((-Ec / KbT))))
	else:
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	tmp = 0.0
	if ((Ec <= -2.7e+19) || !(Ec <= 4.9e+33))
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))));
	else
		tmp = Float64(t_0 + 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)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	tmp = 0.0;
	if ((Ec <= -2.7e+19) || ~((Ec <= 4.9e+33)))
		tmp = t_0 + (NdChar / (1.0 + exp((-Ec / KbT))));
	else
		tmp = t_0 + (NdChar / (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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[Ec, -2.7e+19], N[Not[LessEqual[Ec, 4.9e+33]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 6: 73.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + e^{\frac{Vef}{KbT}}\\ \mathbf{if}\;Vef \leq -3.8 \cdot 10^{+77} \lor \neg \left(Vef \leq 1.65 \cdot 10^{+166}\right):\\ \;\;\;\;\frac{NdChar}{t_0} + \frac{NaChar}{t_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{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 (+ 1.0 (exp (/ Vef KbT)))))
   (if (or (<= Vef -3.8e+77) (not (<= Vef 1.65e+166)))
     (+ (/ NdChar t_0) (/ NaChar t_0))
     (+
      (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) 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 = 1.0 + exp((Vef / KbT));
	double tmp;
	if ((Vef <= -3.8e+77) || !(Vef <= 1.65e+166)) {
		tmp = (NdChar / t_0) + (NaChar / t_0);
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / 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 = 1.0d0 + exp((vef / kbt))
    if ((vef <= (-3.8d+77)) .or. (.not. (vef <= 1.65d+166))) then
        tmp = (ndchar / t_0) + (nachar / t_0)
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / 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 = 1.0 + Math.exp((Vef / KbT));
	double tmp;
	if ((Vef <= -3.8e+77) || !(Vef <= 1.65e+166)) {
		tmp = (NdChar / t_0) + (NaChar / t_0);
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + math.exp((Vef / KbT))
	tmp = 0
	if (Vef <= -3.8e+77) or not (Vef <= 1.65e+166):
		tmp = (NdChar / t_0) + (NaChar / t_0)
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / 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(1.0 + exp(Float64(Vef / KbT)))
	tmp = 0.0
	if ((Vef <= -3.8e+77) || !(Vef <= 1.65e+166))
		tmp = Float64(Float64(NdChar / t_0) + Float64(NaChar / t_0));
	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(EDonor / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = 1.0 + exp((Vef / KbT));
	tmp = 0.0;
	if ((Vef <= -3.8e+77) || ~((Vef <= 1.65e+166)))
		tmp = (NdChar / t_0) + (NaChar / t_0);
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / 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[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[Vef, -3.8e+77], N[Not[LessEqual[Vef, 1.65e+166]], $MachinePrecision]], N[(N[(NdChar / t$95$0), $MachinePrecision] + N[(NaChar / t$95$0), $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[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 7: 61.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := NdChar \cdot \frac{1}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{if}\;NdChar \leq -1.7 \cdot 10^{+159}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NdChar \leq -3 \cdot 10^{+20}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.45 \cdot 10^{-135} \lor \neg \left(NdChar \leq 0.000116\right):\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (* NdChar (/ 1.0 (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
          (/
           NaChar
           (-
            (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
            (/ mu KbT))))))
   (if (<= NdChar -1.7e+159)
     t_0
     (if (<= NdChar -3e+20)
       (+
        (/ NdChar (+ 1.0 (exp (/ mu KbT))))
        (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
       (if (or (<= NdChar -2.45e-135) (not (<= NdChar 0.000116)))
         t_0
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec 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 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double tmp;
	if (NdChar <= -1.7e+159) {
		tmp = t_0;
	} else if (NdChar <= -3e+20) {
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else if ((NdChar <= -2.45e-135) || !(NdChar <= 0.000116)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / 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 / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt))))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    if (ndchar <= (-1.7d+159)) then
        tmp = t_0
    else if (ndchar <= (-3d+20)) then
        tmp = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((ev / kbt))))
    else if ((ndchar <= (-2.45d-135)) .or. (.not. (ndchar <= 0.000116d0))) then
        tmp = t_0
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / 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 / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double tmp;
	if (NdChar <= -1.7e+159) {
		tmp = t_0;
	} else if (NdChar <= -3e+20) {
		tmp = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else if ((NdChar <= -2.45e-135) || !(NdChar <= 0.000116)) {
		tmp = t_0;
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar * (1.0 / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	tmp = 0
	if NdChar <= -1.7e+159:
		tmp = t_0
	elif NdChar <= -3e+20:
		tmp = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	elif (NdChar <= -2.45e-135) or not (NdChar <= 0.000116):
		tmp = t_0
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar * Float64(1.0 / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))))
	tmp = 0.0
	if (NdChar <= -1.7e+159)
		tmp = t_0;
	elseif (NdChar <= -3e+20)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Ev / KbT)))));
	elseif ((NdChar <= -2.45e-135) || !(NdChar <= 0.000116))
		tmp = t_0;
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar * (1.0 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	tmp = 0.0;
	if (NdChar <= -1.7e+159)
		tmp = t_0;
	elseif (NdChar <= -3e+20)
		tmp = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((Ev / KbT))));
	elseif ((NdChar <= -2.45e-135) || ~((NdChar <= 0.000116)))
		tmp = t_0;
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / 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[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.7e+159], t$95$0, If[LessEqual[NdChar, -3e+20], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[NdChar, -2.45e-135], N[Not[LessEqual[NdChar, 0.000116]], $MachinePrecision]], t$95$0, 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[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

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

Alternative 8: 61.0% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -2.6 \cdot 10^{+159} \lor \neg \left(NdChar \leq -2.1 \cdot 10^{+60} \lor \neg \left(NdChar \leq -2.45 \cdot 10^{-135}\right) \land NdChar \leq 3.6 \cdot 10^{-5}\right):\\ \;\;\;\;NdChar \cdot \frac{1}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -2.6e+159)
         (not
          (or (<= NdChar -2.1e+60)
              (and (not (<= NdChar -2.45e-135)) (<= NdChar 3.6e-5)))))
   (+
    (* NdChar (/ 1.0 (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
    (/
     NaChar
     (- (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))) (/ mu KbT))))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT)))) (/ Ec 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 <= -2.6e+159) || !((NdChar <= -2.1e+60) || (!(NdChar <= -2.45e-135) && (NdChar <= 3.6e-5)))) {
		tmp = (NdChar * (1.0 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / 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 <= (-2.6d+159)) .or. (.not. (ndchar <= (-2.1d+60)) .or. (.not. (ndchar <= (-2.45d-135))) .and. (ndchar <= 3.6d-5))) then
        tmp = (ndchar * (1.0d0 / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt))))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / 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 <= -2.6e+159) || !((NdChar <= -2.1e+60) || (!(NdChar <= -2.45e-135) && (NdChar <= 3.6e-5)))) {
		tmp = (NdChar * (1.0 / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (NdChar <= -2.6e+159) or not ((NdChar <= -2.1e+60) or (not (NdChar <= -2.45e-135) and (NdChar <= 3.6e-5))):
		tmp = (NdChar * (1.0 / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((NdChar <= -2.6e+159) || !((NdChar <= -2.1e+60) || (!(NdChar <= -2.45e-135) && (NdChar <= 3.6e-5))))
		tmp = Float64(Float64(NdChar * Float64(1.0 / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((NdChar <= -2.6e+159) || ~(((NdChar <= -2.1e+60) || (~((NdChar <= -2.45e-135)) && (NdChar <= 3.6e-5)))))
		tmp = (NdChar * (1.0 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	else
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -2.6e+159], N[Not[Or[LessEqual[NdChar, -2.1e+60], And[N[Not[LessEqual[NdChar, -2.45e-135]], $MachinePrecision], LessEqual[NdChar, 3.6e-5]]]], $MachinePrecision]], N[(N[(NdChar * N[(1.0 / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $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[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 9: 56.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{if}\;KbT \leq -1.8 \cdot 10^{-172}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;KbT \leq -3.8 \cdot 10^{-246}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;KbT \leq 4 \cdot 10^{-99}:\\ \;\;\;\;t_0 + \frac{NdChar}{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1
         (+
          t_0
          (/
           NdChar
           (-
            (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
            (/ Ec KbT))))))
   (if (<= KbT -1.8e-172)
     t_1
     (if (<= KbT -3.8e-246)
       (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
       (if (<= KbT 4e-99)
         (+ t_0 (/ NdChar (/ (- (+ EDonor (+ mu Vef)) Ec) 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 + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -1.8e-172) {
		tmp = t_1;
	} else if (KbT <= -3.8e-246) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else if (KbT <= 4e-99) {
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / 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 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    if (kbt <= (-1.8d-172)) then
        tmp = t_1
    else if (kbt <= (-3.8d-246)) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else if (kbt <= 4d-99) then
        tmp = t_0 + (ndchar / (((edonor + (mu + vef)) - ec) / 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	double tmp;
	if (KbT <= -1.8e-172) {
		tmp = t_1;
	} else if (KbT <= -3.8e-246) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (KbT <= 4e-99) {
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	tmp = 0
	if KbT <= -1.8e-172:
		tmp = t_1
	elif KbT <= -3.8e-246:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	elif KbT <= 4e-99:
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT))
	else:
		tmp = 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(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))))
	tmp = 0.0
	if (KbT <= -1.8e-172)
		tmp = t_1;
	elseif (KbT <= -3.8e-246)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (KbT <= 4e-99)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	tmp = 0.0;
	if (KbT <= -1.8e-172)
		tmp = t_1;
	elseif (KbT <= -3.8e-246)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	elseif (KbT <= 4e-99)
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.8e-172], t$95$1, If[LessEqual[KbT, -3.8e-246], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4e-99], N[(t$95$0 + N[(NdChar / N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 10: 55.9% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{if}\;NdChar \leq -2.6 \cdot 10^{+169}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -1.5 \cdot 10^{+18}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -1.65 \cdot 10^{-112}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{-142}:\\ \;\;\;\;t_0 + \frac{NdChar}{\frac{\left(EDonor + \left(mu + Vef\right)\right) - Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 1.8 \cdot 10^{+106}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ (/ Vef KbT) 2.0))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (* NaChar 0.5))))
   (if (<= NdChar -2.6e+169)
     (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
     (if (<= NdChar -1.5e+18)
       t_1
       (if (<= NdChar -1.65e-112)
         t_2
         (if (<= NdChar 5.5e-142)
           (+ t_0 (/ NdChar (/ (- (+ EDonor (+ mu Vef)) Ec) KbT)))
           (if (<= NdChar 1.8e+106) 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -2.6e+169) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else if (NdChar <= -1.5e+18) {
		tmp = t_1;
	} else if (NdChar <= -1.65e-112) {
		tmp = t_2;
	} else if (NdChar <= 5.5e-142) {
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT));
	} else if (NdChar <= 1.8e+106) {
		tmp = 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) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / ((vef / kbt) + 2.0d0))
    t_2 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar * 0.5d0)
    if (ndchar <= (-2.6d+169)) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else if (ndchar <= (-1.5d+18)) then
        tmp = t_1
    else if (ndchar <= (-1.65d-112)) then
        tmp = t_2
    else if (ndchar <= 5.5d-142) then
        tmp = t_0 + (ndchar / (((edonor + (mu + vef)) - ec) / kbt))
    else if (ndchar <= 1.8d+106) then
        tmp = 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -2.6e+169) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (NdChar <= -1.5e+18) {
		tmp = t_1;
	} else if (NdChar <= -1.65e-112) {
		tmp = t_2;
	} else if (NdChar <= 5.5e-142) {
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT));
	} else if (NdChar <= 1.8e+106) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0))
	t_2 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5)
	tmp = 0
	if NdChar <= -2.6e+169:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	elif NdChar <= -1.5e+18:
		tmp = t_1
	elif NdChar <= -1.65e-112:
		tmp = t_2
	elif NdChar <= 5.5e-142:
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT))
	elif NdChar <= 1.8e+106:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar * 0.5))
	tmp = 0.0
	if (NdChar <= -2.6e+169)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (NdChar <= -1.5e+18)
		tmp = t_1;
	elseif (NdChar <= -1.65e-112)
		tmp = t_2;
	elseif (NdChar <= 5.5e-142)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(EDonor + Float64(mu + Vef)) - Ec) / KbT)));
	elseif (NdChar <= 1.8e+106)
		tmp = 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	tmp = 0.0;
	if (NdChar <= -2.6e+169)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	elseif (NdChar <= -1.5e+18)
		tmp = t_1;
	elseif (NdChar <= -1.65e-112)
		tmp = t_2;
	elseif (NdChar <= 5.5e-142)
		tmp = t_0 + (NdChar / (((EDonor + (mu + Vef)) - Ec) / KbT));
	elseif (NdChar <= 1.8e+106)
		tmp = 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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 * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -2.6e+169], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -1.5e+18], t$95$1, If[LessEqual[NdChar, -1.65e-112], t$95$2, If[LessEqual[NdChar, 5.5e-142], N[(t$95$0 + N[(NdChar / N[(N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.8e+106], t$95$1, t$95$2]]]]]]]]

Derivation

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

Alternative 11: 56.2% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{if}\;NdChar \leq -3.5 \cdot 10^{+171}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -3.1 \cdot 10^{+16}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -3.9 \cdot 10^{-100}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 1.02 \cdot 10^{-141}:\\ \;\;\;\;t_0 + \frac{NdChar \cdot KbT}{\left(EDonor + \left(mu + Vef\right)\right) - Ec}\\ \mathbf{elif}\;NdChar \leq 2.2 \cdot 10^{+109}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ (/ Vef KbT) 2.0))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (* NaChar 0.5))))
   (if (<= NdChar -3.5e+171)
     (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
     (if (<= NdChar -3.1e+16)
       t_1
       (if (<= NdChar -3.9e-100)
         t_2
         (if (<= NdChar 1.02e-141)
           (+ t_0 (/ (* NdChar KbT) (- (+ EDonor (+ mu Vef)) Ec)))
           (if (<= NdChar 2.2e+109) 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -3.5e+171) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else if (NdChar <= -3.1e+16) {
		tmp = t_1;
	} else if (NdChar <= -3.9e-100) {
		tmp = t_2;
	} else if (NdChar <= 1.02e-141) {
		tmp = t_0 + ((NdChar * KbT) / ((EDonor + (mu + Vef)) - Ec));
	} else if (NdChar <= 2.2e+109) {
		tmp = 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) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / ((vef / kbt) + 2.0d0))
    t_2 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar * 0.5d0)
    if (ndchar <= (-3.5d+171)) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else if (ndchar <= (-3.1d+16)) then
        tmp = t_1
    else if (ndchar <= (-3.9d-100)) then
        tmp = t_2
    else if (ndchar <= 1.02d-141) then
        tmp = t_0 + ((ndchar * kbt) / ((edonor + (mu + vef)) - ec))
    else if (ndchar <= 2.2d+109) then
        tmp = 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -3.5e+171) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (NdChar <= -3.1e+16) {
		tmp = t_1;
	} else if (NdChar <= -3.9e-100) {
		tmp = t_2;
	} else if (NdChar <= 1.02e-141) {
		tmp = t_0 + ((NdChar * KbT) / ((EDonor + (mu + Vef)) - Ec));
	} else if (NdChar <= 2.2e+109) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0))
	t_2 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5)
	tmp = 0
	if NdChar <= -3.5e+171:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	elif NdChar <= -3.1e+16:
		tmp = t_1
	elif NdChar <= -3.9e-100:
		tmp = t_2
	elif NdChar <= 1.02e-141:
		tmp = t_0 + ((NdChar * KbT) / ((EDonor + (mu + Vef)) - Ec))
	elif NdChar <= 2.2e+109:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar * 0.5))
	tmp = 0.0
	if (NdChar <= -3.5e+171)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (NdChar <= -3.1e+16)
		tmp = t_1;
	elseif (NdChar <= -3.9e-100)
		tmp = t_2;
	elseif (NdChar <= 1.02e-141)
		tmp = Float64(t_0 + Float64(Float64(NdChar * KbT) / Float64(Float64(EDonor + Float64(mu + Vef)) - Ec)));
	elseif (NdChar <= 2.2e+109)
		tmp = 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	tmp = 0.0;
	if (NdChar <= -3.5e+171)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	elseif (NdChar <= -3.1e+16)
		tmp = t_1;
	elseif (NdChar <= -3.9e-100)
		tmp = t_2;
	elseif (NdChar <= 1.02e-141)
		tmp = t_0 + ((NdChar * KbT) / ((EDonor + (mu + Vef)) - Ec));
	elseif (NdChar <= 2.2e+109)
		tmp = 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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 * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -3.5e+171], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -3.1e+16], t$95$1, If[LessEqual[NdChar, -3.9e-100], t$95$2, If[LessEqual[NdChar, 1.02e-141], N[(t$95$0 + N[(N[(NdChar * KbT), $MachinePrecision] / N[(N[(EDonor + N[(mu + Vef), $MachinePrecision]), $MachinePrecision] - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 2.2e+109], t$95$1, t$95$2]]]]]]]]

Derivation

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

Alternative 12: 56.6% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_1 := t_0 + \frac{NdChar}{\frac{Vef}{KbT} + 2}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{if}\;NdChar \leq -5.6 \cdot 10^{+165}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{elif}\;NdChar \leq -2.2 \cdot 10^{+16}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq -1.08 \cdot 10^{-100}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq -2.4 \cdot 10^{-135}:\\ \;\;\;\;t_0 - \frac{KbT}{\frac{Ec}{NdChar}}\\ \mathbf{elif}\;NdChar \leq 1.45 \cdot 10^{+106}:\\ \;\;\;\;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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ t_0 (/ NdChar (+ (/ Vef KbT) 2.0))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (* NaChar 0.5))))
   (if (<= NdChar -5.6e+165)
     (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
     (if (<= NdChar -2.2e+16)
       t_1
       (if (<= NdChar -1.08e-100)
         t_2
         (if (<= NdChar -2.4e-135)
           (- t_0 (/ KbT (/ Ec NdChar)))
           (if (<= NdChar 1.45e+106) 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -5.6e+165) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else if (NdChar <= -2.2e+16) {
		tmp = t_1;
	} else if (NdChar <= -1.08e-100) {
		tmp = t_2;
	} else if (NdChar <= -2.4e-135) {
		tmp = t_0 - (KbT / (Ec / NdChar));
	} else if (NdChar <= 1.45e+106) {
		tmp = 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) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = t_0 + (ndchar / ((vef / kbt) + 2.0d0))
    t_2 = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar * 0.5d0)
    if (ndchar <= (-5.6d+165)) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else if (ndchar <= (-2.2d+16)) then
        tmp = t_1
    else if (ndchar <= (-1.08d-100)) then
        tmp = t_2
    else if (ndchar <= (-2.4d-135)) then
        tmp = t_0 - (kbt / (ec / ndchar))
    else if (ndchar <= 1.45d+106) then
        tmp = 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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	double t_2 = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	double tmp;
	if (NdChar <= -5.6e+165) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else if (NdChar <= -2.2e+16) {
		tmp = t_1;
	} else if (NdChar <= -1.08e-100) {
		tmp = t_2;
	} else if (NdChar <= -2.4e-135) {
		tmp = t_0 - (KbT / (Ec / NdChar));
	} else if (NdChar <= 1.45e+106) {
		tmp = t_1;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0))
	t_2 = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5)
	tmp = 0
	if NdChar <= -5.6e+165:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	elif NdChar <= -2.2e+16:
		tmp = t_1
	elif NdChar <= -1.08e-100:
		tmp = t_2
	elif NdChar <= -2.4e-135:
		tmp = t_0 - (KbT / (Ec / NdChar))
	elif NdChar <= 1.45e+106:
		tmp = t_1
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_1 = Float64(t_0 + Float64(NdChar / Float64(Float64(Vef / KbT) + 2.0)))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar * 0.5))
	tmp = 0.0
	if (NdChar <= -5.6e+165)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	elseif (NdChar <= -2.2e+16)
		tmp = t_1;
	elseif (NdChar <= -1.08e-100)
		tmp = t_2;
	elseif (NdChar <= -2.4e-135)
		tmp = Float64(t_0 - Float64(KbT / Float64(Ec / NdChar)));
	elseif (NdChar <= 1.45e+106)
		tmp = 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = t_0 + (NdChar / ((Vef / KbT) + 2.0));
	t_2 = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	tmp = 0.0;
	if (NdChar <= -5.6e+165)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	elseif (NdChar <= -2.2e+16)
		tmp = t_1;
	elseif (NdChar <= -1.08e-100)
		tmp = t_2;
	elseif (NdChar <= -2.4e-135)
		tmp = t_0 - (KbT / (Ec / NdChar));
	elseif (NdChar <= 1.45e+106)
		tmp = 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[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + N[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 + N[(NdChar / N[(N[(Vef / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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 * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -5.6e+165], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, -2.2e+16], t$95$1, If[LessEqual[NdChar, -1.08e-100], t$95$2, If[LessEqual[NdChar, -2.4e-135], N[(t$95$0 - N[(KbT / N[(Ec / NdChar), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 1.45e+106], t$95$1, t$95$2]]]]]]]]

Derivation

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

Alternative 13: 53.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{if}\;NaChar \leq -1.7 \cdot 10^{-76}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -1.85 \cdot 10^{-289}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 8.5 \cdot 10^{-125}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + NaChar \cdot 0.5\\ \mathbf{elif}\;NaChar \leq 2 \cdot 10^{-43}:\\ \;\;\;\;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 (/ Vef KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar 2.0))))
   (if (<= NaChar -1.7e-76)
     t_1
     (if (<= NaChar -1.85e-289)
       t_0
       (if (<= NaChar 8.5e-125)
         (+
          (/ NdChar (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT))))
          (* NaChar 0.5))
         (if (<= NaChar 2e-43) 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((Vef / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.7e-76) {
		tmp = t_1;
	} else if (NaChar <= -1.85e-289) {
		tmp = t_0;
	} else if (NaChar <= 8.5e-125) {
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	} else if (NaChar <= 2e-43) {
		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((vef / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / 2.0d0)
    if (nachar <= (-1.7d-76)) then
        tmp = t_1
    else if (nachar <= (-1.85d-289)) then
        tmp = t_0
    else if (nachar <= 8.5d-125) then
        tmp = (ndchar / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt)))) + (nachar * 0.5d0)
    else if (nachar <= 2d-43) 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((Vef / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.7e-76) {
		tmp = t_1;
	} else if (NaChar <= -1.85e-289) {
		tmp = t_0;
	} else if (NaChar <= 8.5e-125) {
		tmp = (NdChar / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	} else if (NaChar <= 2e-43) {
		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((Vef / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0)
	tmp = 0
	if NaChar <= -1.7e-76:
		tmp = t_1
	elif NaChar <= -1.85e-289:
		tmp = t_0
	elif NaChar <= 8.5e-125:
		tmp = (NdChar / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5)
	elif NaChar <= 2e-43:
		tmp = t_0
	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(Vef / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / 2.0))
	tmp = 0.0
	if (NaChar <= -1.7e-76)
		tmp = t_1;
	elseif (NaChar <= -1.85e-289)
		tmp = t_0;
	elseif (NaChar <= 8.5e-125)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT)))) + Float64(NaChar * 0.5));
	elseif (NaChar <= 2e-43)
		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((Vef / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	tmp = 0.0;
	if (NaChar <= -1.7e-76)
		tmp = t_1;
	elseif (NaChar <= -1.85e-289)
		tmp = t_0;
	elseif (NaChar <= 8.5e-125)
		tmp = (NdChar / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT)))) + (NaChar * 0.5);
	elseif (NaChar <= 2e-43)
		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[(NdChar / N[(1.0 + N[Exp[N[(Vef / 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 / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.7e-76], t$95$1, If[LessEqual[NaChar, -1.85e-289], t$95$0, If[LessEqual[NaChar, 8.5e-125], 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 * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 2e-43], t$95$0, t$95$1]]]]]]

Derivation

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

Alternative 14: 53.2% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{if}\;NaChar \leq -1.06 \cdot 10^{-69}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq -4.3 \cdot 10^{-289}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;NaChar \leq 5 \cdot 10^{-126}:\\ \;\;\;\;NdChar \cdot \frac{1}{1 + e^{\frac{mu + \left(EDonor + \left(Vef - Ec\right)\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;NaChar \leq 3.5 \cdot 10^{-42}:\\ \;\;\;\;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 (/ Vef KbT)))))
        (t_1
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
          (/ NdChar 2.0))))
   (if (<= NaChar -1.06e-69)
     t_1
     (if (<= NaChar -4.3e-289)
       t_0
       (if (<= NaChar 5e-126)
         (+
          (* NdChar (/ 1.0 (+ 1.0 (exp (/ (+ mu (+ EDonor (- Vef Ec))) KbT)))))
          (/ NaChar 2.0))
         (if (<= NaChar 3.5e-42) 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((Vef / KbT)));
	double t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.06e-69) {
		tmp = t_1;
	} else if (NaChar <= -4.3e-289) {
		tmp = t_0;
	} else if (NaChar <= 5e-126) {
		tmp = (NdChar * (1.0 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / 2.0);
	} else if (NaChar <= 3.5e-42) {
		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((vef / kbt)))
    t_1 = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / 2.0d0)
    if (nachar <= (-1.06d-69)) then
        tmp = t_1
    else if (nachar <= (-4.3d-289)) then
        tmp = t_0
    else if (nachar <= 5d-126) then
        tmp = (ndchar * (1.0d0 / (1.0d0 + exp(((mu + (edonor + (vef - ec))) / kbt))))) + (nachar / 2.0d0)
    else if (nachar <= 3.5d-42) 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((Vef / KbT)));
	double t_1 = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	double tmp;
	if (NaChar <= -1.06e-69) {
		tmp = t_1;
	} else if (NaChar <= -4.3e-289) {
		tmp = t_0;
	} else if (NaChar <= 5e-126) {
		tmp = (NdChar * (1.0 / (1.0 + Math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / 2.0);
	} else if (NaChar <= 3.5e-42) {
		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((Vef / KbT)))
	t_1 = (NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0)
	tmp = 0
	if NaChar <= -1.06e-69:
		tmp = t_1
	elif NaChar <= -4.3e-289:
		tmp = t_0
	elif NaChar <= 5e-126:
		tmp = (NdChar * (1.0 / (1.0 + math.exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / 2.0)
	elif NaChar <= 3.5e-42:
		tmp = t_0
	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(Vef / KbT))))
	t_1 = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT)))) + Float64(NdChar / 2.0))
	tmp = 0.0
	if (NaChar <= -1.06e-69)
		tmp = t_1;
	elseif (NaChar <= -4.3e-289)
		tmp = t_0;
	elseif (NaChar <= 5e-126)
		tmp = Float64(Float64(NdChar * Float64(1.0 / Float64(1.0 + exp(Float64(Float64(mu + Float64(EDonor + Float64(Vef - Ec))) / KbT))))) + Float64(NaChar / 2.0));
	elseif (NaChar <= 3.5e-42)
		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((Vef / KbT)));
	t_1 = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	tmp = 0.0;
	if (NaChar <= -1.06e-69)
		tmp = t_1;
	elseif (NaChar <= -4.3e-289)
		tmp = t_0;
	elseif (NaChar <= 5e-126)
		tmp = (NdChar * (1.0 / (1.0 + exp(((mu + (EDonor + (Vef - Ec))) / KbT))))) + (NaChar / 2.0);
	elseif (NaChar <= 3.5e-42)
		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[(NdChar / N[(1.0 + N[Exp[N[(Vef / 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 / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NaChar, -1.06e-69], t$95$1, If[LessEqual[NaChar, -4.3e-289], t$95$0, If[LessEqual[NaChar, 5e-126], N[(N[(NdChar * N[(1.0 / N[(1.0 + N[Exp[N[(N[(mu + N[(EDonor + N[(Vef - Ec), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 3.5e-42], t$95$0, t$95$1]]]]]]

Derivation

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

Alternative 15: 51.5% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -4.9 \cdot 10^{-64} \lor \neg \left(NaChar \leq 1.18 \cdot 10^{-42}\right):\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}} + \frac{NdChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -4.9e-64) (not (<= NaChar 1.18e-42)))
   (+
    (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))
    (/ NdChar 2.0))
   (/ NdChar (+ 1.0 (exp (/ Vef 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 ((NaChar <= -4.9e-64) || !(NaChar <= 1.18e-42)) {
		tmp = (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = NdChar / (1.0 + exp((Vef / 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 ((nachar <= (-4.9d-64)) .or. (.not. (nachar <= 1.18d-42))) then
        tmp = (nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))) + (ndchar / 2.0d0)
    else
        tmp = ndchar / (1.0d0 + exp((vef / 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 ((NaChar <= -4.9e-64) || !(NaChar <= 1.18e-42)) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))) + (NdChar / 2.0);
	} else {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NaChar, -4.9e-64], N[Not[LessEqual[NaChar, 1.18e-42]], $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 / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 16: 42.2% accurate, 2.0× speedup

Math

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

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NaChar -2.95e-24) (not (<= NaChar 1.6e-42)))
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
   (/ NdChar (+ 1.0 (exp (/ Vef 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 ((NaChar <= -2.95e-24) || !(NaChar <= 1.6e-42)) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else {
		tmp = NdChar / (1.0 + exp((Vef / 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 ((nachar <= (-2.95d-24)) .or. (.not. (nachar <= 1.6d-42))) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else
        tmp = ndchar / (1.0d0 + exp((vef / 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 ((NaChar <= -2.95e-24) || !(NaChar <= 1.6e-42)) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	}
	return tmp;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 17: 42.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NaChar \leq -1.08 \cdot 10^{-23}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;NaChar \leq 6.6 \cdot 10^{-40}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Ev}{KbT}}} + \frac{NdChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= NaChar -1.08e-23)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
   (if (<= NaChar 6.6e-40)
     (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
     (+ (/ NaChar (+ 1.0 (exp (/ Ev 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 (NaChar <= -1.08e-23) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (NaChar <= 6.6e-40) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = (NaChar / (1.0 + exp((Ev / 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 (nachar <= (-1.08d-23)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (nachar <= 6.6d-40) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = (nachar / (1.0d0 + exp((ev / 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 (NaChar <= -1.08e-23) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (NaChar <= 6.6e-40) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = (NaChar / (1.0 + Math.exp((Ev / KbT)))) + (NdChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if NaChar <= -1.08e-23:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif NaChar <= 6.6e-40:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	else:
		tmp = (NaChar / (1.0 + math.exp((Ev / KbT)))) + (NdChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (NaChar <= -1.08e-23)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / Float64(1.0 + exp(Float64(EAccept / KbT)))));
	elseif (NaChar <= 6.6e-40)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Ev / 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 (NaChar <= -1.08e-23)
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	elseif (NaChar <= 6.6e-40)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	else
		tmp = (NaChar / (1.0 + exp((Ev / KbT)))) + (NdChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[NaChar, -1.08e-23], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NaChar, 6.6e-40], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 18: 42.2% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -4.4 \cdot 10^{+105}:\\ \;\;\;\;\frac{NdChar}{2} + \left(-0.25 \cdot \frac{NaChar \cdot Ev}{KbT} + NaChar \cdot 0.5\right)\\ \mathbf{elif}\;KbT \leq 4.2 \cdot 10^{+158}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -4.4e+105)
   (+ (/ NdChar 2.0) (+ (* -0.25 (/ (* NaChar Ev) KbT)) (* NaChar 0.5)))
   (if (<= KbT 4.2e+158)
     (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
     (+
      (/
       NaChar
       (- (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))) (/ mu KbT)))
      (/
       NdChar
       (-
        (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT))))
        (/ Ec 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 (KbT <= -4.4e+105) {
		tmp = (NdChar / 2.0) + ((-0.25 * ((NaChar * Ev) / KbT)) + (NaChar * 0.5));
	} else if (KbT <= 4.2e+158) {
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	} else {
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / 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 (kbt <= (-4.4d+105)) then
        tmp = (ndchar / 2.0d0) + (((-0.25d0) * ((nachar * ev) / kbt)) + (nachar * 0.5d0))
    else if (kbt <= 4.2d+158) then
        tmp = ndchar / (1.0d0 + exp((vef / kbt)))
    else
        tmp = (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / 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 (KbT <= -4.4e+105) {
		tmp = (NdChar / 2.0) + ((-0.25 * ((NaChar * Ev) / KbT)) + (NaChar * 0.5));
	} else if (KbT <= 4.2e+158) {
		tmp = NdChar / (1.0 + Math.exp((Vef / KbT)));
	} else {
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -4.4e+105:
		tmp = (NdChar / 2.0) + ((-0.25 * ((NaChar * Ev) / KbT)) + (NaChar * 0.5))
	elif KbT <= 4.2e+158:
		tmp = NdChar / (1.0 + math.exp((Vef / KbT)))
	else:
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -4.4e+105)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(Float64(-0.25 * Float64(Float64(NaChar * Ev) / KbT)) + Float64(NaChar * 0.5)));
	elseif (KbT <= 4.2e+158)
		tmp = Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT))));
	else
		tmp = Float64(Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -4.4e+105)
		tmp = (NdChar / 2.0) + ((-0.25 * ((NaChar * Ev) / KbT)) + (NaChar * 0.5));
	elseif (KbT <= 4.2e+158)
		tmp = NdChar / (1.0 + exp((Vef / KbT)));
	else
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -4.4e+105], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(N[(-0.25 * N[(N[(NaChar * Ev), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] + N[(NaChar * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 4.2e+158], N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / N[(N[(2.0 + N[(N[(EAccept / KbT), $MachinePrecision] + N[(N[(Vef / KbT), $MachinePrecision] + N[(Ev / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 19: 27.4% accurate, 5.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Vef \leq -7.4 \cdot 10^{-103}:\\ \;\;\;\;\frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}} + \frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= Vef -7.4e-103)
   (+
    (/
     NaChar
     (- (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT)))) (/ mu KbT)))
    (/
     NdChar
     (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT)))) (/ Ec KbT))))
   (+ (/ NdChar 2.0) (/ 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 (Vef <= -7.4e-103) {
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else {
		tmp = (NdChar / 2.0) + (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 (vef <= (-7.4d-103)) then
        tmp = (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt))) + (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / kbt)))
    else
        tmp = (ndchar / 2.0d0) + (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 (Vef <= -7.4e-103) {
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	} else {
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if Vef <= -7.4e-103:
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)))
	else:
		tmp = (NdChar / 2.0) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (Vef <= -7.4e-103)
		tmp = Float64(Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))) + Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / KbT))));
	else
		tmp = Float64(Float64(NdChar / 2.0) + 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 (Vef <= -7.4e-103)
		tmp = (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT))) + (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT)));
	else
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 20: 27.8% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.5 \cdot 10^{-201}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 1.7 \cdot 10^{-53}:\\ \;\;\;\;\frac{NdChar \cdot KbT}{mu}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{\left(2 + \left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right)\right) - \frac{Ec}{KbT}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.5e-201)
   (+ (/ NdChar 2.0) (/ NaChar 2.0))
   (if (<= KbT 1.7e-53)
     (/ (* NdChar KbT) mu)
     (+
      (/
       NdChar
       (- (+ 2.0 (+ (/ EDonor KbT) (+ (/ mu KbT) (/ Vef KbT)))) (/ Ec 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 (KbT <= -1.5e-201) {
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	} else if (KbT <= 1.7e-53) {
		tmp = (NdChar * KbT) / mu;
	} else {
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / 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 (kbt <= (-1.5d-201)) then
        tmp = (ndchar / 2.0d0) + (nachar / 2.0d0)
    else if (kbt <= 1.7d-53) then
        tmp = (ndchar * kbt) / mu
    else
        tmp = (ndchar / ((2.0d0 + ((edonor / kbt) + ((mu / kbt) + (vef / kbt)))) - (ec / 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 (KbT <= -1.5e-201) {
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	} else if (KbT <= 1.7e-53) {
		tmp = (NdChar * KbT) / mu;
	} else {
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.5e-201:
		tmp = (NdChar / 2.0) + (NaChar / 2.0)
	elif KbT <= 1.7e-53:
		tmp = (NdChar * KbT) / mu
	else:
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.5e-201)
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / 2.0));
	elseif (KbT <= 1.7e-53)
		tmp = Float64(Float64(NdChar * KbT) / mu);
	else
		tmp = Float64(Float64(NdChar / Float64(Float64(2.0 + Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + Float64(Vef / KbT)))) - Float64(Ec / 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 (KbT <= -1.5e-201)
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	elseif (KbT <= 1.7e-53)
		tmp = (NdChar * KbT) / mu;
	else
		tmp = (NdChar / ((2.0 + ((EDonor / KbT) + ((mu / KbT) + (Vef / KbT)))) - (Ec / KbT))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.5e-201], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.7e-53], N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision], N[(N[(NdChar / N[(N[(2.0 + N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 21: 28.4% accurate, 20.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -2.15 \cdot 10^{-201} \lor \neg \left(KbT \leq 5.8 \cdot 10^{-92}\right):\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar \cdot KbT}{mu}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -2.15e-201) (not (<= KbT 5.8e-92)))
   (+ (/ NdChar 2.0) (/ NaChar 2.0))
   (/ (* NdChar KbT) 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 <= -2.15e-201) || !(KbT <= 5.8e-92)) {
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	} else {
		tmp = (NdChar * KbT) / 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 <= (-2.15d-201)) .or. (.not. (kbt <= 5.8d-92))) then
        tmp = (ndchar / 2.0d0) + (nachar / 2.0d0)
    else
        tmp = (ndchar * kbt) / 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 <= -2.15e-201) || !(KbT <= 5.8e-92)) {
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	} else {
		tmp = (NdChar * KbT) / mu;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -2.15e-201) or not (KbT <= 5.8e-92):
		tmp = (NdChar / 2.0) + (NaChar / 2.0)
	else:
		tmp = (NdChar * KbT) / mu
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -2.15e-201) || !(KbT <= 5.8e-92))
		tmp = Float64(Float64(NdChar / 2.0) + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NdChar * KbT) / mu);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -2.15e-201) || ~((KbT <= 5.8e-92)))
		tmp = (NdChar / 2.0) + (NaChar / 2.0);
	else
		tmp = (NdChar * KbT) / mu;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -2.15e-201], N[Not[LessEqual[KbT, 5.8e-92]], $MachinePrecision]], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]]

Derivation

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

Alternative 22: 19.5% accurate, 25.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -3.7 \cdot 10^{-71} \lor \neg \left(KbT \leq 2.9 \cdot 10^{-92}\right):\\ \;\;\;\;NaChar \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar \cdot KbT}{mu}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= KbT -3.7e-71) (not (<= KbT 2.9e-92)))
   (* NaChar 0.5)
   (/ (* NdChar KbT) 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 <= -3.7e-71) || !(KbT <= 2.9e-92)) {
		tmp = NaChar * 0.5;
	} else {
		tmp = (NdChar * KbT) / 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 <= (-3.7d-71)) .or. (.not. (kbt <= 2.9d-92))) then
        tmp = nachar * 0.5d0
    else
        tmp = (ndchar * kbt) / 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 <= -3.7e-71) || !(KbT <= 2.9e-92)) {
		tmp = NaChar * 0.5;
	} else {
		tmp = (NdChar * KbT) / mu;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if (KbT <= -3.7e-71) or not (KbT <= 2.9e-92):
		tmp = NaChar * 0.5
	else:
		tmp = (NdChar * KbT) / mu
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -3.7e-71) || !(KbT <= 2.9e-92))
		tmp = Float64(NaChar * 0.5);
	else
		tmp = Float64(Float64(NdChar * KbT) / mu);
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if ((KbT <= -3.7e-71) || ~((KbT <= 2.9e-92)))
		tmp = NaChar * 0.5;
	else
		tmp = (NdChar * KbT) / mu;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[KbT, -3.7e-71], N[Not[LessEqual[KbT, 2.9e-92]], $MachinePrecision]], N[(NaChar * 0.5), $MachinePrecision], N[(N[(NdChar * KbT), $MachinePrecision] / mu), $MachinePrecision]]

Derivation

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

Alternative 23: 18.1% accurate, 76.3× speedup

Math

\[\begin{array}{l} \\ NaChar \cdot 0.5 \end{array} \]

FPCore

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

C

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

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 * 0.5d0
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 * 0.5;
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

herbie shell --seed 2023350 
(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))))))