Bulmash initializePoisson

Percentage Accurate: 100.0% → 100.0%

Time: 39.8s

Alternatives: 28

Speedup: 1.0×

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.5× speedup

Math

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

FPCore

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

C

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

Java

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

Julia

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

Wolfram

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

Derivation

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

Alternative 2: 63.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_3 := 1 + \frac{EDonor}{KbT}\\ \mathbf{if}\;mu \leq -4.8 \cdot 10^{+182}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.7 \cdot 10^{-182}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(t_3 + \frac{\frac{Vef \cdot KbT + mu \cdot KbT}{KbT}}{KbT}\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq -4.8 \cdot 10^{-264}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 2.4 \cdot 10^{-210}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(t_3 + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 1.25 \cdot 10^{+36}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;mu \leq 6.7 \cdot 10^{+121}:\\ \;\;\;\;t_1 + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;mu \leq 2.5 \cdot 10^{+183}:\\ \;\;\;\;NdChar + t_1\\ \mathbf{elif}\;mu \leq 2.8 \cdot 10^{+185}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(t_3 + \frac{KbT + mu \cdot \frac{KbT}{Vef}}{KbT \cdot \frac{KbT}{Vef}}\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0
         (+
          (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
          (/
           NaChar
           (-
            (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
            (/ mu KbT)))))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_3 (+ 1.0 (/ EDonor KbT))))
   (if (<= mu -4.8e+182)
     t_2
     (if (<= mu -1.7e-182)
       (+
        t_1
        (/
         NdChar
         (+
          1.0
          (- (+ t_3 (/ (/ (+ (* Vef KbT) (* mu KbT)) KbT) KbT)) (/ Ec KbT)))))
       (if (<= mu -4.8e-264)
         t_0
         (if (<= mu 2.4e-210)
           (+
            t_1
            (/
             NdChar
             (+ 1.0 (- (+ t_3 (+ (/ mu KbT) (/ Vef KbT))) (/ Ec KbT)))))
           (if (<= mu 1.25e+36)
             t_0
             (if (<= mu 6.7e+121)
               (+
                t_1
                (/
                 NdChar
                 (- (+ (/ EDonor KbT) (+ (/ mu KbT) 2.0)) (/ Ec KbT))))
               (if (<= mu 2.5e+183)
                 (+ NdChar t_1)
                 (if (<= mu 2.8e+185)
                   (+
                    t_1
                    (/
                     NdChar
                     (+
                      1.0
                      (-
                       (+
                        t_3
                        (/ (+ KbT (* mu (/ KbT Vef))) (* KbT (/ KbT Vef))))
                       (/ Ec KbT)))))
                   t_2))))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double t_1 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_3 = 1.0 + (EDonor / KbT);
	double tmp;
	if (mu <= -4.8e+182) {
		tmp = t_2;
	} else if (mu <= -1.7e-182) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	} else if (mu <= -4.8e-264) {
		tmp = t_0;
	} else if (mu <= 2.4e-210) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 1.25e+36) {
		tmp = t_0;
	} else if (mu <= 6.7e+121) {
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (mu <= 2.5e+183) {
		tmp = NdChar + t_1;
	} else if (mu <= 2.8e+185) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((KbT + (mu * (KbT / Vef))) / (KbT * (KbT / Vef)))) - (Ec / KbT))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    t_1 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_3 = 1.0d0 + (edonor / kbt)
    if (mu <= (-4.8d+182)) then
        tmp = t_2
    else if (mu <= (-1.7d-182)) then
        tmp = t_1 + (ndchar / (1.0d0 + ((t_3 + ((((vef * kbt) + (mu * kbt)) / kbt) / kbt)) - (ec / kbt))))
    else if (mu <= (-4.8d-264)) then
        tmp = t_0
    else if (mu <= 2.4d-210) then
        tmp = t_1 + (ndchar / (1.0d0 + ((t_3 + ((mu / kbt) + (vef / kbt))) - (ec / kbt))))
    else if (mu <= 1.25d+36) then
        tmp = t_0
    else if (mu <= 6.7d+121) then
        tmp = t_1 + (ndchar / (((edonor / kbt) + ((mu / kbt) + 2.0d0)) - (ec / kbt)))
    else if (mu <= 2.5d+183) then
        tmp = ndchar + t_1
    else if (mu <= 2.8d+185) then
        tmp = t_1 + (ndchar / (1.0d0 + ((t_3 + ((kbt + (mu * (kbt / vef))) / (kbt * (kbt / vef)))) - (ec / kbt))))
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_3 = 1.0 + (EDonor / KbT);
	double tmp;
	if (mu <= -4.8e+182) {
		tmp = t_2;
	} else if (mu <= -1.7e-182) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	} else if (mu <= -4.8e-264) {
		tmp = t_0;
	} else if (mu <= 2.4e-210) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 1.25e+36) {
		tmp = t_0;
	} else if (mu <= 6.7e+121) {
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (mu <= 2.5e+183) {
		tmp = NdChar + t_1;
	} else if (mu <= 2.8e+185) {
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((KbT + (mu * (KbT / Vef))) / (KbT * (KbT / Vef)))) - (Ec / KbT))));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	t_1 = NaChar / (1.0 + math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_3 = 1.0 + (EDonor / KbT)
	tmp = 0
	if mu <= -4.8e+182:
		tmp = t_2
	elif mu <= -1.7e-182:
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))))
	elif mu <= -4.8e-264:
		tmp = t_0
	elif mu <= 2.4e-210:
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))))
	elif mu <= 1.25e+36:
		tmp = t_0
	elif mu <= 6.7e+121:
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)))
	elif mu <= 2.5e+183:
		tmp = NdChar + t_1
	elif mu <= 2.8e+185:
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((KbT + (mu * (KbT / Vef))) / (KbT * (KbT / Vef)))) - (Ec / KbT))))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + Float64(EAccept + Float64(Ev - mu))) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_3 = Float64(1.0 + Float64(EDonor / KbT))
	tmp = 0.0
	if (mu <= -4.8e+182)
		tmp = t_2;
	elseif (mu <= -1.7e-182)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(t_3 + Float64(Float64(Float64(Float64(Vef * KbT) + Float64(mu * KbT)) / KbT) / KbT)) - Float64(Ec / KbT)))));
	elseif (mu <= -4.8e-264)
		tmp = t_0;
	elseif (mu <= 2.4e-210)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(t_3 + Float64(Float64(mu / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT)))));
	elseif (mu <= 1.25e+36)
		tmp = t_0;
	elseif (mu <= 6.7e+121)
		tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + 2.0)) - Float64(Ec / KbT))));
	elseif (mu <= 2.5e+183)
		tmp = Float64(NdChar + t_1);
	elseif (mu <= 2.8e+185)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(t_3 + Float64(Float64(KbT + Float64(mu * Float64(KbT / Vef))) / Float64(KbT * Float64(KbT / Vef)))) - Float64(Ec / KbT)))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	t_1 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_3 = 1.0 + (EDonor / KbT);
	tmp = 0.0;
	if (mu <= -4.8e+182)
		tmp = t_2;
	elseif (mu <= -1.7e-182)
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	elseif (mu <= -4.8e-264)
		tmp = t_0;
	elseif (mu <= 2.4e-210)
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	elseif (mu <= 1.25e+36)
		tmp = t_0;
	elseif (mu <= 6.7e+121)
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	elseif (mu <= 2.5e+183)
		tmp = NdChar + t_1;
	elseif (mu <= 2.8e+185)
		tmp = t_1 + (NdChar / (1.0 + ((t_3 + ((KbT + (mu * (KbT / Vef))) / (KbT * (KbT / Vef)))) - (Ec / KbT))));
	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[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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]}, Block[{t$95$1 = 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$2 = 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]}, Block[{t$95$3 = N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.8e+182], t$95$2, If[LessEqual[mu, -1.7e-182], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(t$95$3 + N[(N[(N[(N[(Vef * KbT), $MachinePrecision] + N[(mu * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -4.8e-264], t$95$0, If[LessEqual[mu, 2.4e-210], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(t$95$3 + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.25e+36], t$95$0, If[LessEqual[mu, 6.7e+121], N[(t$95$1 + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 2.5e+183], N[(NdChar + t$95$1), $MachinePrecision], If[LessEqual[mu, 2.8e+185], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(t$95$3 + N[(N[(KbT + N[(mu * N[(KbT / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(KbT * N[(KbT / Vef), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]]]

Derivation

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

Alternative 3: 66.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := EAccept + \left(Ev - mu\right)\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{t_0}{KbT}}}\\ \mathbf{if}\;mu \leq -7.4 \cdot 10^{+118}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -1.55 \cdot 10^{-238}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.06 \cdot 10^{-271}:\\ \;\;\;\;\frac{NaChar}{1 + e^{\frac{Vef + t_0}{KbT}}} + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 4.4 \cdot 10^{-204}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq 1.25 \cdot 10^{+35}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;mu \leq 4.5 \cdot 10^{+183}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ EAccept (- Ev mu)))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))
          (/ NaChar (+ 1.0 (exp (/ t_0 KbT)))))))
   (if (<= mu -7.4e+118)
     t_1
     (if (<= mu -1.55e-238)
       t_2
       (if (<= mu 1.06e-271)
         (+
          (/ NaChar (+ 1.0 (exp (/ (+ Vef t_0) KbT))))
          (/
           NdChar
           (+
            1.0
            (-
             (+ (+ 1.0 (/ EDonor KbT)) (+ (/ mu KbT) (/ Vef KbT)))
             (/ Ec KbT)))))
         (if (<= mu 4.4e-204)
           t_2
           (if (<= mu 1.25e+35)
             (+
              (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
              (/
               NaChar
               (-
                (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
                (/ mu KbT))))
             (if (<= mu 4.5e+183) t_2 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 = EAccept + (Ev - mu);
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_2 = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((t_0 / KbT))));
	double tmp;
	if (mu <= -7.4e+118) {
		tmp = t_1;
	} else if (mu <= -1.55e-238) {
		tmp = t_2;
	} else if (mu <= 1.06e-271) {
		tmp = (NaChar / (1.0 + exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 4.4e-204) {
		tmp = t_2;
	} else if (mu <= 1.25e+35) {
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else if (mu <= 4.5e+183) {
		tmp = t_2;
	} 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) :: t_2
    real(8) :: tmp
    t_0 = eaccept + (ev - mu)
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_2 = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / (1.0d0 + exp((t_0 / kbt))))
    if (mu <= (-7.4d+118)) then
        tmp = t_1
    else if (mu <= (-1.55d-238)) then
        tmp = t_2
    else if (mu <= 1.06d-271) then
        tmp = (nachar / (1.0d0 + exp(((vef + t_0) / kbt)))) + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((mu / kbt) + (vef / kbt))) - (ec / kbt))))
    else if (mu <= 4.4d-204) then
        tmp = t_2
    else if (mu <= 1.25d+35) then
        tmp = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    else if (mu <= 4.5d+183) then
        tmp = t_2
    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 = EAccept + (Ev - mu);
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_2 = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / (1.0 + Math.exp((t_0 / KbT))));
	double tmp;
	if (mu <= -7.4e+118) {
		tmp = t_1;
	} else if (mu <= -1.55e-238) {
		tmp = t_2;
	} else if (mu <= 1.06e-271) {
		tmp = (NaChar / (1.0 + Math.exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 4.4e-204) {
		tmp = t_2;
	} else if (mu <= 1.25e+35) {
		tmp = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else if (mu <= 4.5e+183) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = EAccept + (Ev - mu)
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_2 = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp((t_0 / KbT))))
	tmp = 0
	if mu <= -7.4e+118:
		tmp = t_1
	elif mu <= -1.55e-238:
		tmp = t_2
	elif mu <= 1.06e-271:
		tmp = (NaChar / (1.0 + math.exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))))
	elif mu <= 4.4e-204:
		tmp = t_2
	elif mu <= 1.25e+35:
		tmp = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	elif mu <= 4.5e+183:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(EAccept + Float64(Ev - mu))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(t_0 / KbT)))))
	tmp = 0.0
	if (mu <= -7.4e+118)
		tmp = t_1;
	elseif (mu <= -1.55e-238)
		tmp = t_2;
	elseif (mu <= 1.06e-271)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + t_0) / KbT)))) + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(mu / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT)))));
	elseif (mu <= 4.4e-204)
		tmp = t_2;
	elseif (mu <= 1.25e+35)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))));
	elseif (mu <= 4.5e+183)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = EAccept + (Ev - mu);
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_2 = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((t_0 / KbT))));
	tmp = 0.0;
	if (mu <= -7.4e+118)
		tmp = t_1;
	elseif (mu <= -1.55e-238)
		tmp = t_2;
	elseif (mu <= 1.06e-271)
		tmp = (NaChar / (1.0 + exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	elseif (mu <= 4.4e-204)
		tmp = t_2;
	elseif (mu <= 1.25e+35)
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	elseif (mu <= 4.5e+183)
		tmp = t_2;
	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[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(t$95$0 / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -7.4e+118], t$95$1, If[LessEqual[mu, -1.55e-238], t$95$2, If[LessEqual[mu, 1.06e-271], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + t$95$0), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 4.4e-204], t$95$2, If[LessEqual[mu, 1.25e+35], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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[mu, 4.5e+183], t$95$2, t$95$1]]]]]]]]]

Derivation

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

Alternative 4: 73.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := EAccept + \left(Ev - mu\right)\\ t_1 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_2 := \frac{NaChar}{1 + e^{\frac{Vef + t_0}{KbT}}}\\ t_3 := t_2 + \frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}}\\ t_4 := t_2 + \frac{NdChar}{1 + e^{\frac{Vef}{KbT}}}\\ \mathbf{if}\;mu \leq -4.7 \cdot 10^{+179}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;mu \leq -2.6 \cdot 10^{+57}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;mu \leq -2.15 \cdot 10^{-45}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq -3.2 \cdot 10^{-241}:\\ \;\;\;\;t_4\\ \mathbf{elif}\;mu \leq 10^{-6}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 5.8 \cdot 10^{+184}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{1 + e^{\frac{t_0}{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 (+ EAccept (- Ev mu)))
        (t_1
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_2 (/ NaChar (+ 1.0 (exp (/ (+ Vef t_0) KbT)))))
        (t_3 (+ t_2 (/ NdChar (+ 1.0 (exp (/ EDonor KbT))))))
        (t_4 (+ t_2 (/ NdChar (+ 1.0 (exp (/ Vef KbT)))))))
   (if (<= mu -4.7e+179)
     t_1
     (if (<= mu -2.6e+57)
       t_4
       (if (<= mu -2.15e-45)
         t_3
         (if (<= mu -3.2e-241)
           t_4
           (if (<= mu 1e-6)
             t_3
             (if (<= mu 5.8e+184)
               (+
                (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT))))
                (/ NaChar (+ 1.0 (exp (/ t_0 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 = EAccept + (Ev - mu);
	double t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_2 = NaChar / (1.0 + exp(((Vef + t_0) / KbT)));
	double t_3 = t_2 + (NdChar / (1.0 + exp((EDonor / KbT))));
	double t_4 = t_2 + (NdChar / (1.0 + exp((Vef / KbT))));
	double tmp;
	if (mu <= -4.7e+179) {
		tmp = t_1;
	} else if (mu <= -2.6e+57) {
		tmp = t_4;
	} else if (mu <= -2.15e-45) {
		tmp = t_3;
	} else if (mu <= -3.2e-241) {
		tmp = t_4;
	} else if (mu <= 1e-6) {
		tmp = t_3;
	} else if (mu <= 5.8e+184) {
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((t_0 / 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) :: t_2
    real(8) :: t_3
    real(8) :: t_4
    real(8) :: tmp
    t_0 = eaccept + (ev - mu)
    t_1 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_2 = nachar / (1.0d0 + exp(((vef + t_0) / kbt)))
    t_3 = t_2 + (ndchar / (1.0d0 + exp((edonor / kbt))))
    t_4 = t_2 + (ndchar / (1.0d0 + exp((vef / kbt))))
    if (mu <= (-4.7d+179)) then
        tmp = t_1
    else if (mu <= (-2.6d+57)) then
        tmp = t_4
    else if (mu <= (-2.15d-45)) then
        tmp = t_3
    else if (mu <= (-3.2d-241)) then
        tmp = t_4
    else if (mu <= 1d-6) then
        tmp = t_3
    else if (mu <= 5.8d+184) then
        tmp = (ndchar / (1.0d0 + exp((-ec / kbt)))) + (nachar / (1.0d0 + exp((t_0 / 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 = EAccept + (Ev - mu);
	double t_1 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_2 = NaChar / (1.0 + Math.exp(((Vef + t_0) / KbT)));
	double t_3 = t_2 + (NdChar / (1.0 + Math.exp((EDonor / KbT))));
	double t_4 = t_2 + (NdChar / (1.0 + Math.exp((Vef / KbT))));
	double tmp;
	if (mu <= -4.7e+179) {
		tmp = t_1;
	} else if (mu <= -2.6e+57) {
		tmp = t_4;
	} else if (mu <= -2.15e-45) {
		tmp = t_3;
	} else if (mu <= -3.2e-241) {
		tmp = t_4;
	} else if (mu <= 1e-6) {
		tmp = t_3;
	} else if (mu <= 5.8e+184) {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / (1.0 + Math.exp((t_0 / KbT))));
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = EAccept + (Ev - mu)
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_2 = NaChar / (1.0 + math.exp(((Vef + t_0) / KbT)))
	t_3 = t_2 + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	t_4 = t_2 + (NdChar / (1.0 + math.exp((Vef / KbT))))
	tmp = 0
	if mu <= -4.7e+179:
		tmp = t_1
	elif mu <= -2.6e+57:
		tmp = t_4
	elif mu <= -2.15e-45:
		tmp = t_3
	elif mu <= -3.2e-241:
		tmp = t_4
	elif mu <= 1e-6:
		tmp = t_3
	elif mu <= 5.8e+184:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp((t_0 / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(EAccept + Float64(Ev - mu))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_2 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + t_0) / KbT))))
	t_3 = Float64(t_2 + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))))
	t_4 = Float64(t_2 + Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))))
	tmp = 0.0
	if (mu <= -4.7e+179)
		tmp = t_1;
	elseif (mu <= -2.6e+57)
		tmp = t_4;
	elseif (mu <= -2.15e-45)
		tmp = t_3;
	elseif (mu <= -3.2e-241)
		tmp = t_4;
	elseif (mu <= 1e-6)
		tmp = t_3;
	elseif (mu <= 5.8e+184)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(t_0 / 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 = EAccept + (Ev - mu);
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_2 = NaChar / (1.0 + exp(((Vef + t_0) / KbT)));
	t_3 = t_2 + (NdChar / (1.0 + exp((EDonor / KbT))));
	t_4 = t_2 + (NdChar / (1.0 + exp((Vef / KbT))));
	tmp = 0.0;
	if (mu <= -4.7e+179)
		tmp = t_1;
	elseif (mu <= -2.6e+57)
		tmp = t_4;
	elseif (mu <= -2.15e-45)
		tmp = t_3;
	elseif (mu <= -3.2e-241)
		tmp = t_4;
	elseif (mu <= 1e-6)
		tmp = t_3;
	elseif (mu <= 5.8e+184)
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((t_0 / 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[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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]}, Block[{t$95$2 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + t$95$0), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 + N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[mu, -4.7e+179], t$95$1, If[LessEqual[mu, -2.6e+57], t$95$4, If[LessEqual[mu, -2.15e-45], t$95$3, If[LessEqual[mu, -3.2e-241], t$95$4, If[LessEqual[mu, 1e-6], t$95$3, If[LessEqual[mu, 5.8e+184], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(t$95$0 / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]]]]]]]

Derivation

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

Alternative 5: 64.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := EAccept + \left(Ev - mu\right)\\ t_1 := \frac{NaChar}{1 + e^{\frac{Vef + t_0}{KbT}}}\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{1 + e^{\frac{-mu}{KbT}}}\\ t_3 := \frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\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}\;mu \leq -7 \cdot 10^{+138}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;mu \leq -1.9 \cdot 10^{-182}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{1 + e^{\frac{t_0}{KbT}}}\\ \mathbf{elif}\;mu \leq -3.85 \cdot 10^{-264}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 4.8 \cdot 10^{-207}:\\ \;\;\;\;t_1 + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;mu \leq 1.32 \cdot 10^{+35}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;mu \leq 3.95 \cdot 10^{+118}:\\ \;\;\;\;t_1 + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ EAccept (- Ev mu)))
        (t_1 (/ NaChar (+ 1.0 (exp (/ (+ Vef t_0) KbT)))))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ mu KbT))))
          (/ NaChar (+ 1.0 (exp (/ (- mu) KbT))))))
        (t_3
         (+
          (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
          (/
           NaChar
           (-
            (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
            (/ mu KbT))))))
   (if (<= mu -7e+138)
     t_2
     (if (<= mu -1.9e-182)
       (+
        (/ NdChar (+ 1.0 (exp (/ Vef KbT))))
        (/ NaChar (+ 1.0 (exp (/ t_0 KbT)))))
       (if (<= mu -3.85e-264)
         t_3
         (if (<= mu 4.8e-207)
           (+
            t_1
            (/
             NdChar
             (+
              1.0
              (-
               (+ (+ 1.0 (/ EDonor KbT)) (+ (/ mu KbT) (/ Vef KbT)))
               (/ Ec KbT)))))
           (if (<= mu 1.32e+35)
             t_3
             (if (<= mu 3.95e+118)
               (+
                t_1
                (/
                 NdChar
                 (- (+ (/ EDonor KbT) (+ (/ mu KbT) 2.0)) (/ Ec KbT))))
               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 = EAccept + (Ev - mu);
	double t_1 = NaChar / (1.0 + exp(((Vef + t_0) / KbT)));
	double t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	double t_3 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double tmp;
	if (mu <= -7e+138) {
		tmp = t_2;
	} else if (mu <= -1.9e-182) {
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((t_0 / KbT))));
	} else if (mu <= -3.85e-264) {
		tmp = t_3;
	} else if (mu <= 4.8e-207) {
		tmp = t_1 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 1.32e+35) {
		tmp = t_3;
	} else if (mu <= 3.95e+118) {
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = eaccept + (ev - mu)
    t_1 = nachar / (1.0d0 + exp(((vef + t_0) / kbt)))
    t_2 = (ndchar / (1.0d0 + exp((mu / kbt)))) + (nachar / (1.0d0 + exp((-mu / kbt))))
    t_3 = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    if (mu <= (-7d+138)) then
        tmp = t_2
    else if (mu <= (-1.9d-182)) then
        tmp = (ndchar / (1.0d0 + exp((vef / kbt)))) + (nachar / (1.0d0 + exp((t_0 / kbt))))
    else if (mu <= (-3.85d-264)) then
        tmp = t_3
    else if (mu <= 4.8d-207) then
        tmp = t_1 + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((mu / kbt) + (vef / kbt))) - (ec / kbt))))
    else if (mu <= 1.32d+35) then
        tmp = t_3
    else if (mu <= 3.95d+118) then
        tmp = t_1 + (ndchar / (((edonor / kbt) + ((mu / kbt) + 2.0d0)) - (ec / kbt)))
    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 = EAccept + (Ev - mu);
	double t_1 = NaChar / (1.0 + Math.exp(((Vef + t_0) / KbT)));
	double t_2 = (NdChar / (1.0 + Math.exp((mu / KbT)))) + (NaChar / (1.0 + Math.exp((-mu / KbT))));
	double t_3 = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	double tmp;
	if (mu <= -7e+138) {
		tmp = t_2;
	} else if (mu <= -1.9e-182) {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / (1.0 + Math.exp((t_0 / KbT))));
	} else if (mu <= -3.85e-264) {
		tmp = t_3;
	} else if (mu <= 4.8e-207) {
		tmp = t_1 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if (mu <= 1.32e+35) {
		tmp = t_3;
	} else if (mu <= 3.95e+118) {
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else {
		tmp = t_2;
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = EAccept + (Ev - mu)
	t_1 = NaChar / (1.0 + math.exp(((Vef + t_0) / KbT)))
	t_2 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	t_3 = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	tmp = 0
	if mu <= -7e+138:
		tmp = t_2
	elif mu <= -1.9e-182:
		tmp = (NdChar / (1.0 + math.exp((Vef / KbT)))) + (NaChar / (1.0 + math.exp((t_0 / KbT))))
	elif mu <= -3.85e-264:
		tmp = t_3
	elif mu <= 4.8e-207:
		tmp = t_1 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))))
	elif mu <= 1.32e+35:
		tmp = t_3
	elif mu <= 3.95e+118:
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)))
	else:
		tmp = t_2
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(EAccept + Float64(Ev - mu))
	t_1 = Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + t_0) / KbT))))
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	t_3 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / 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 (mu <= -7e+138)
		tmp = t_2;
	elseif (mu <= -1.9e-182)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(t_0 / KbT)))));
	elseif (mu <= -3.85e-264)
		tmp = t_3;
	elseif (mu <= 4.8e-207)
		tmp = Float64(t_1 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(mu / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT)))));
	elseif (mu <= 1.32e+35)
		tmp = t_3;
	elseif (mu <= 3.95e+118)
		tmp = Float64(t_1 + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + 2.0)) - Float64(Ec / KbT))));
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = EAccept + (Ev - mu);
	t_1 = NaChar / (1.0 + exp(((Vef + t_0) / KbT)));
	t_2 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	t_3 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	tmp = 0.0;
	if (mu <= -7e+138)
		tmp = t_2;
	elseif (mu <= -1.9e-182)
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / (1.0 + exp((t_0 / KbT))));
	elseif (mu <= -3.85e-264)
		tmp = t_3;
	elseif (mu <= 4.8e-207)
		tmp = t_1 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	elseif (mu <= 1.32e+35)
		tmp = t_3;
	elseif (mu <= 3.95e+118)
		tmp = t_1 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	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[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + t$95$0), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = 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]}, Block[{t$95$3 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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[mu, -7e+138], t$95$2, If[LessEqual[mu, -1.9e-182], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(t$95$0 / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, -3.85e-264], t$95$3, If[LessEqual[mu, 4.8e-207], N[(t$95$1 + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 1.32e+35], t$95$3, If[LessEqual[mu, 3.95e+118], N[(t$95$1 + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]]]

Derivation

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

Alternative 6: 100.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 7: 72.9% accurate, 1.0× speedup

Math

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = EAccept + (Ev - mu)
	t_1 = (NdChar / (1.0 + math.exp((mu / KbT)))) + (NaChar / (1.0 + math.exp((-mu / KbT))))
	tmp = 0
	if mu <= -7.6e+167:
		tmp = t_1
	elif mu <= 1.7e-5:
		tmp = (NaChar / (1.0 + math.exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + math.exp((EDonor / KbT))))
	elif mu <= 3.6e+183:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / (1.0 + math.exp((t_0 / KbT))))
	else:
		tmp = t_1
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(EAccept + Float64(Ev - mu))
	t_1 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(Float64(-mu) / KbT)))))
	tmp = 0.0
	if (mu <= -7.6e+167)
		tmp = t_1;
	elseif (mu <= 1.7e-5)
		tmp = Float64(Float64(NaChar / Float64(1.0 + exp(Float64(Float64(Vef + t_0) / KbT)))) + Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))));
	elseif (mu <= 3.6e+183)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(-Ec) / KbT)))) + Float64(NaChar / Float64(1.0 + exp(Float64(t_0 / 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 = EAccept + (Ev - mu);
	t_1 = (NdChar / (1.0 + exp((mu / KbT)))) + (NaChar / (1.0 + exp((-mu / KbT))));
	tmp = 0.0;
	if (mu <= -7.6e+167)
		tmp = t_1;
	elseif (mu <= 1.7e-5)
		tmp = (NaChar / (1.0 + exp(((Vef + t_0) / KbT)))) + (NdChar / (1.0 + exp((EDonor / KbT))));
	elseif (mu <= 3.6e+183)
		tmp = (NdChar / (1.0 + exp((-Ec / KbT)))) + (NaChar / (1.0 + exp((t_0 / 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[(EAccept + N[(Ev - mu), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = 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[mu, -7.6e+167], t$95$1, If[LessEqual[mu, 1.7e-5], N[(N[(NaChar / N[(1.0 + N[Exp[N[(N[(Vef + t$95$0), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[mu, 3.6e+183], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(t$95$0 / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 8: 76.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}}}\\ \mathbf{if}\;mu \leq -1.9 \cdot 10^{+63} \lor \neg \left(mu \leq 5.2 \cdot 10^{-42}\right):\\ \;\;\;\;t_0 + \frac{NdChar}{1 + e^{\frac{mu}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;t_0 + \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 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT))))))
   (if (or (<= mu -1.9e+63) (not (<= mu 5.2e-42)))
     (+ t_0 (/ NdChar (+ 1.0 (exp (/ mu KbT)))))
     (+ t_0 (/ 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if ((mu <= -1.9e+63) || !(mu <= 5.2e-42)) {
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	} else {
		tmp = t_0 + (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 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    if ((mu <= (-1.9d+63)) .or. (.not. (mu <= 5.2d-42))) then
        tmp = t_0 + (ndchar / (1.0d0 + exp((mu / kbt))))
    else
        tmp = t_0 + (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 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double tmp;
	if ((mu <= -1.9e+63) || !(mu <= 5.2e-42)) {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((mu / KbT))));
	} else {
		tmp = t_0 + (NdChar / (1.0 + Math.exp((EDonor / 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 (mu <= -1.9e+63) or not (mu <= 5.2e-42):
		tmp = t_0 + (NdChar / (1.0 + math.exp((mu / KbT))))
	else:
		tmp = t_0 + (NdChar / (1.0 + math.exp((EDonor / 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 ((mu <= -1.9e+63) || !(mu <= 5.2e-42))
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + exp(Float64(mu / KbT)))));
	else
		tmp = Float64(t_0 + 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 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	tmp = 0.0;
	if ((mu <= -1.9e+63) || ~((mu <= 5.2e-42)))
		tmp = t_0 + (NdChar / (1.0 + exp((mu / KbT))));
	else
		tmp = t_0 + (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[(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[mu, -1.9e+63], N[Not[LessEqual[mu, 5.2e-42]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 + N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 9: 58.1% accurate, 1.3× 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 := NdChar + t_0\\ t_2 := \left(mu + Vef\right) \cdot \frac{-1}{KbT} - \frac{EDonor}{KbT}\\ t_3 := t_0 + \frac{NdChar}{1 + \left(\frac{1 - t_2 \cdot t_2}{1 + t_2} - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;Ec \leq -4.6 \cdot 10^{+180}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;Ec \leq -4.35 \cdot 10^{-16}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq -2.45 \cdot 10^{-91}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;Ec \leq -3.8 \cdot 10^{-297}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq 0.17:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \frac{\frac{Vef \cdot KbT + mu \cdot KbT}{KbT}}{KbT}\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ec \leq 4.1 \cdot 10^{+158} \lor \neg \left(Ec \leq 2.35 \cdot 10^{+191}\right):\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_3\\ \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 (+ NdChar t_0))
        (t_2 (- (* (+ mu Vef) (/ -1.0 KbT)) (/ EDonor KbT)))
        (t_3
         (+
          t_0
          (/
           NdChar
           (+ 1.0 (- (/ (- 1.0 (* t_2 t_2)) (+ 1.0 t_2)) (/ Ec KbT)))))))
   (if (<= Ec -4.6e+180)
     (+ t_0 (/ NdChar (- 1.0 (/ Ec KbT))))
     (if (<= Ec -4.35e-16)
       t_1
       (if (<= Ec -2.45e-91)
         t_3
         (if (<= Ec -3.8e-297)
           t_1
           (if (<= Ec 0.17)
             (+
              t_0
              (/
               NdChar
               (+
                1.0
                (-
                 (+
                  (+ 1.0 (/ EDonor KbT))
                  (/ (/ (+ (* Vef KbT) (* mu KbT)) KbT) KbT))
                 (/ Ec KbT)))))
             (if (or (<= Ec 4.1e+158) (not (<= Ec 2.35e+191))) t_1 t_3))))))))

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 = NdChar + t_0;
	double t_2 = ((mu + Vef) * (-1.0 / KbT)) - (EDonor / KbT);
	double t_3 = t_0 + (NdChar / (1.0 + (((1.0 - (t_2 * t_2)) / (1.0 + t_2)) - (Ec / KbT))));
	double tmp;
	if (Ec <= -4.6e+180) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -4.35e-16) {
		tmp = t_1;
	} else if (Ec <= -2.45e-91) {
		tmp = t_3;
	} else if (Ec <= -3.8e-297) {
		tmp = t_1;
	} else if (Ec <= 0.17) {
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	} else if ((Ec <= 4.1e+158) || !(Ec <= 2.35e+191)) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = ndchar + t_0
    t_2 = ((mu + vef) * ((-1.0d0) / kbt)) - (edonor / kbt)
    t_3 = t_0 + (ndchar / (1.0d0 + (((1.0d0 - (t_2 * t_2)) / (1.0d0 + t_2)) - (ec / kbt))))
    if (ec <= (-4.6d+180)) then
        tmp = t_0 + (ndchar / (1.0d0 - (ec / kbt)))
    else if (ec <= (-4.35d-16)) then
        tmp = t_1
    else if (ec <= (-2.45d-91)) then
        tmp = t_3
    else if (ec <= (-3.8d-297)) then
        tmp = t_1
    else if (ec <= 0.17d0) then
        tmp = t_0 + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((((vef * kbt) + (mu * kbt)) / kbt) / kbt)) - (ec / kbt))))
    else if ((ec <= 4.1d+158) .or. (.not. (ec <= 2.35d+191))) then
        tmp = t_1
    else
        tmp = t_3
    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 = NdChar + t_0;
	double t_2 = ((mu + Vef) * (-1.0 / KbT)) - (EDonor / KbT);
	double t_3 = t_0 + (NdChar / (1.0 + (((1.0 - (t_2 * t_2)) / (1.0 + t_2)) - (Ec / KbT))));
	double tmp;
	if (Ec <= -4.6e+180) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -4.35e-16) {
		tmp = t_1;
	} else if (Ec <= -2.45e-91) {
		tmp = t_3;
	} else if (Ec <= -3.8e-297) {
		tmp = t_1;
	} else if (Ec <= 0.17) {
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	} else if ((Ec <= 4.1e+158) || !(Ec <= 2.35e+191)) {
		tmp = t_1;
	} else {
		tmp = t_3;
	}
	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 = NdChar + t_0
	t_2 = ((mu + Vef) * (-1.0 / KbT)) - (EDonor / KbT)
	t_3 = t_0 + (NdChar / (1.0 + (((1.0 - (t_2 * t_2)) / (1.0 + t_2)) - (Ec / KbT))))
	tmp = 0
	if Ec <= -4.6e+180:
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)))
	elif Ec <= -4.35e-16:
		tmp = t_1
	elif Ec <= -2.45e-91:
		tmp = t_3
	elif Ec <= -3.8e-297:
		tmp = t_1
	elif Ec <= 0.17:
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))))
	elif (Ec <= 4.1e+158) or not (Ec <= 2.35e+191):
		tmp = t_1
	else:
		tmp = t_3
	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(NdChar + t_0)
	t_2 = Float64(Float64(Float64(mu + Vef) * Float64(-1.0 / KbT)) - Float64(EDonor / KbT))
	t_3 = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 - Float64(t_2 * t_2)) / Float64(1.0 + t_2)) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (Ec <= -4.6e+180)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))));
	elseif (Ec <= -4.35e-16)
		tmp = t_1;
	elseif (Ec <= -2.45e-91)
		tmp = t_3;
	elseif (Ec <= -3.8e-297)
		tmp = t_1;
	elseif (Ec <= 0.17)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(Float64(Float64(Vef * KbT) + Float64(mu * KbT)) / KbT) / KbT)) - Float64(Ec / KbT)))));
	elseif ((Ec <= 4.1e+158) || !(Ec <= 2.35e+191))
		tmp = t_1;
	else
		tmp = t_3;
	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 = NdChar + t_0;
	t_2 = ((mu + Vef) * (-1.0 / KbT)) - (EDonor / KbT);
	t_3 = t_0 + (NdChar / (1.0 + (((1.0 - (t_2 * t_2)) / (1.0 + t_2)) - (Ec / KbT))));
	tmp = 0.0;
	if (Ec <= -4.6e+180)
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	elseif (Ec <= -4.35e-16)
		tmp = t_1;
	elseif (Ec <= -2.45e-91)
		tmp = t_3;
	elseif (Ec <= -3.8e-297)
		tmp = t_1;
	elseif (Ec <= 0.17)
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	elseif ((Ec <= 4.1e+158) || ~((Ec <= 2.35e+191)))
		tmp = t_1;
	else
		tmp = t_3;
	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[(NdChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(mu + Vef), $MachinePrecision] * N[(-1.0 / KbT), $MachinePrecision]), $MachinePrecision] - N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 - N[(t$95$2 * t$95$2), $MachinePrecision]), $MachinePrecision] / N[(1.0 + t$95$2), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -4.6e+180], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -4.35e-16], t$95$1, If[LessEqual[Ec, -2.45e-91], t$95$3, If[LessEqual[Ec, -3.8e-297], t$95$1, If[LessEqual[Ec, 0.17], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(Vef * KbT), $MachinePrecision] + N[(mu * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ec, 4.1e+158], N[Not[LessEqual[Ec, 2.35e+191]], $MachinePrecision]], t$95$1, t$95$3]]]]]]]]]]

Derivation

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

Alternative 10: 58.9% accurate, 1.5× 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 := NdChar + t_0\\ t_2 := t_0 + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \frac{\frac{Vef \cdot KbT + mu \cdot KbT}{KbT}}{KbT}\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{if}\;Ec \leq -5.2 \cdot 10^{+181}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;Ec \leq -5.4 \cdot 10^{-14}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq -1.05 \cdot 10^{-126}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Ec \leq -4 \cdot 10^{-299}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq 1.25 \cdot 10^{-6}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;Ec \leq 7 \cdot 10^{+157} \lor \neg \left(Ec \leq 6.2 \cdot 10^{+209}\right):\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \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)))))
        (t_1 (+ NdChar t_0))
        (t_2
         (+
          t_0
          (/
           NdChar
           (+
            1.0
            (-
             (+
              (+ 1.0 (/ EDonor KbT))
              (/ (/ (+ (* Vef KbT) (* mu KbT)) KbT) KbT))
             (/ Ec KbT)))))))
   (if (<= Ec -5.2e+181)
     (+ t_0 (/ NdChar (- 1.0 (/ Ec KbT))))
     (if (<= Ec -5.4e-14)
       t_1
       (if (<= Ec -1.05e-126)
         t_2
         (if (<= Ec -4e-299)
           t_1
           (if (<= Ec 1.25e-6)
             t_2
             (if (or (<= Ec 7e+157) (not (<= Ec 6.2e+209)))
               t_1
               (+
                (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
                (/
                 NaChar
                 (-
                  (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
                  (/ 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 t_1 = NdChar + t_0;
	double t_2 = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	double tmp;
	if (Ec <= -5.2e+181) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -5.4e-14) {
		tmp = t_1;
	} else if (Ec <= -1.05e-126) {
		tmp = t_2;
	} else if (Ec <= -4e-299) {
		tmp = t_1;
	} else if (Ec <= 1.25e-6) {
		tmp = t_2;
	} else if ((Ec <= 7e+157) || !(Ec <= 6.2e+209)) {
		tmp = t_1;
	} else {
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = ndchar + t_0
    t_2 = t_0 + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((((vef * kbt) + (mu * kbt)) / kbt) / kbt)) - (ec / kbt))))
    if (ec <= (-5.2d+181)) then
        tmp = t_0 + (ndchar / (1.0d0 - (ec / kbt)))
    else if (ec <= (-5.4d-14)) then
        tmp = t_1
    else if (ec <= (-1.05d-126)) then
        tmp = t_2
    else if (ec <= (-4d-299)) then
        tmp = t_1
    else if (ec <= 1.25d-6) then
        tmp = t_2
    else if ((ec <= 7d+157) .or. (.not. (ec <= 6.2d+209))) then
        tmp = t_1
    else
        tmp = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (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 t_1 = NdChar + t_0;
	double t_2 = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	double tmp;
	if (Ec <= -5.2e+181) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -5.4e-14) {
		tmp = t_1;
	} else if (Ec <= -1.05e-126) {
		tmp = t_2;
	} else if (Ec <= -4e-299) {
		tmp = t_1;
	} else if (Ec <= 1.25e-6) {
		tmp = t_2;
	} else if ((Ec <= 7e+157) || !(Ec <= 6.2e+209)) {
		tmp = t_1;
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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)))
	t_1 = NdChar + t_0
	t_2 = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))))
	tmp = 0
	if Ec <= -5.2e+181:
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)))
	elif Ec <= -5.4e-14:
		tmp = t_1
	elif Ec <= -1.05e-126:
		tmp = t_2
	elif Ec <= -4e-299:
		tmp = t_1
	elif Ec <= 1.25e-6:
		tmp = t_2
	elif (Ec <= 7e+157) or not (Ec <= 6.2e+209):
		tmp = t_1
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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))))
	t_1 = Float64(NdChar + t_0)
	t_2 = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(Float64(Float64(Vef * KbT) + Float64(mu * KbT)) / KbT) / KbT)) - Float64(Ec / KbT)))))
	tmp = 0.0
	if (Ec <= -5.2e+181)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))));
	elseif (Ec <= -5.4e-14)
		tmp = t_1;
	elseif (Ec <= -1.05e-126)
		tmp = t_2;
	elseif (Ec <= -4e-299)
		tmp = t_1;
	elseif (Ec <= 1.25e-6)
		tmp = t_2;
	elseif ((Ec <= 7e+157) || !(Ec <= 6.2e+209))
		tmp = t_1;
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - 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)));
	t_1 = NdChar + t_0;
	t_2 = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((((Vef * KbT) + (mu * KbT)) / KbT) / KbT)) - (Ec / KbT))));
	tmp = 0.0;
	if (Ec <= -5.2e+181)
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	elseif (Ec <= -5.4e-14)
		tmp = t_1;
	elseif (Ec <= -1.05e-126)
		tmp = t_2;
	elseif (Ec <= -4e-299)
		tmp = t_1;
	elseif (Ec <= 1.25e-6)
		tmp = t_2;
	elseif ((Ec <= 7e+157) || ~((Ec <= 6.2e+209)))
		tmp = t_1;
	else
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(N[(Vef * KbT), $MachinePrecision] + N[(mu * KbT), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision] / KbT), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[Ec, -5.2e+181], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -5.4e-14], t$95$1, If[LessEqual[Ec, -1.05e-126], t$95$2, If[LessEqual[Ec, -4e-299], t$95$1, If[LessEqual[Ec, 1.25e-6], t$95$2, If[Or[LessEqual[Ec, 7e+157], N[Not[LessEqual[Ec, 6.2e+209]], $MachinePrecision]], t$95$1, N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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]]]]]]]]]]

Derivation

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

Alternative 11: 59.1% 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 := NdChar + t_0\\ \mathbf{if}\;Ec \leq -7.6 \cdot 10^{+182}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 - \frac{Ec}{KbT}}\\ \mathbf{elif}\;Ec \leq -6.2 \cdot 10^{-16}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq -1.8 \cdot 10^{-95}:\\ \;\;\;\;t_0 + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;Ec \leq -1.75 \cdot 10^{-298}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;Ec \leq 3 \cdot 10^{-138}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)}\\ \mathbf{elif}\;Ec \leq 3.6 \cdot 10^{+158} \lor \neg \left(Ec \leq 9.6 \cdot 10^{+210}\right):\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \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)))))
        (t_1 (+ NdChar t_0)))
   (if (<= Ec -7.6e+182)
     (+ t_0 (/ NdChar (- 1.0 (/ Ec KbT))))
     (if (<= Ec -6.2e-16)
       t_1
       (if (<= Ec -1.8e-95)
         (+
          t_0
          (/ NdChar (- (+ (/ EDonor KbT) (+ (/ mu KbT) 2.0)) (/ Ec KbT))))
         (if (<= Ec -1.75e-298)
           t_1
           (if (<= Ec 3e-138)
             (+
              t_0
              (/
               NdChar
               (+
                1.0
                (-
                 (+ (+ 1.0 (/ EDonor KbT)) (+ (/ mu KbT) (/ Vef KbT)))
                 (/ Ec KbT)))))
             (if (or (<= Ec 3.6e+158) (not (<= Ec 9.6e+210)))
               t_1
               (+
                (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
                (/
                 NaChar
                 (-
                  (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
                  (/ 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 t_1 = NdChar + t_0;
	double tmp;
	if (Ec <= -7.6e+182) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -6.2e-16) {
		tmp = t_1;
	} else if (Ec <= -1.8e-95) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (Ec <= -1.75e-298) {
		tmp = t_1;
	} else if (Ec <= 3e-138) {
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if ((Ec <= 3.6e+158) || !(Ec <= 9.6e+210)) {
		tmp = t_1;
	} else {
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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) :: t_1
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = ndchar + t_0
    if (ec <= (-7.6d+182)) then
        tmp = t_0 + (ndchar / (1.0d0 - (ec / kbt)))
    else if (ec <= (-6.2d-16)) then
        tmp = t_1
    else if (ec <= (-1.8d-95)) then
        tmp = t_0 + (ndchar / (((edonor / kbt) + ((mu / kbt) + 2.0d0)) - (ec / kbt)))
    else if (ec <= (-1.75d-298)) then
        tmp = t_1
    else if (ec <= 3d-138) then
        tmp = t_0 + (ndchar / (1.0d0 + (((1.0d0 + (edonor / kbt)) + ((mu / kbt) + (vef / kbt))) - (ec / kbt))))
    else if ((ec <= 3.6d+158) .or. (.not. (ec <= 9.6d+210))) then
        tmp = t_1
    else
        tmp = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (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 t_1 = NdChar + t_0;
	double tmp;
	if (Ec <= -7.6e+182) {
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	} else if (Ec <= -6.2e-16) {
		tmp = t_1;
	} else if (Ec <= -1.8e-95) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (Ec <= -1.75e-298) {
		tmp = t_1;
	} else if (Ec <= 3e-138) {
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	} else if ((Ec <= 3.6e+158) || !(Ec <= 9.6e+210)) {
		tmp = t_1;
	} else {
		tmp = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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)))
	t_1 = NdChar + t_0
	tmp = 0
	if Ec <= -7.6e+182:
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)))
	elif Ec <= -6.2e-16:
		tmp = t_1
	elif Ec <= -1.8e-95:
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)))
	elif Ec <= -1.75e-298:
		tmp = t_1
	elif Ec <= 3e-138:
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))))
	elif (Ec <= 3.6e+158) or not (Ec <= 9.6e+210):
		tmp = t_1
	else:
		tmp = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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))))
	t_1 = Float64(NdChar + t_0)
	tmp = 0.0
	if (Ec <= -7.6e+182)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 - Float64(Ec / KbT))));
	elseif (Ec <= -6.2e-16)
		tmp = t_1;
	elseif (Ec <= -1.8e-95)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + 2.0)) - Float64(Ec / KbT))));
	elseif (Ec <= -1.75e-298)
		tmp = t_1;
	elseif (Ec <= 3e-138)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + Float64(EDonor / KbT)) + Float64(Float64(mu / KbT) + Float64(Vef / KbT))) - Float64(Ec / KbT)))));
	elseif ((Ec <= 3.6e+158) || !(Ec <= 9.6e+210))
		tmp = t_1;
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - 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)));
	t_1 = NdChar + t_0;
	tmp = 0.0;
	if (Ec <= -7.6e+182)
		tmp = t_0 + (NdChar / (1.0 - (Ec / KbT)));
	elseif (Ec <= -6.2e-16)
		tmp = t_1;
	elseif (Ec <= -1.8e-95)
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	elseif (Ec <= -1.75e-298)
		tmp = t_1;
	elseif (Ec <= 3e-138)
		tmp = t_0 + (NdChar / (1.0 + (((1.0 + (EDonor / KbT)) + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT))));
	elseif ((Ec <= 3.6e+158) || ~((Ec <= 9.6e+210)))
		tmp = t_1;
	else
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (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]}, Block[{t$95$1 = N[(NdChar + t$95$0), $MachinePrecision]}, If[LessEqual[Ec, -7.6e+182], N[(t$95$0 + N[(NdChar / N[(1.0 - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -6.2e-16], t$95$1, If[LessEqual[Ec, -1.8e-95], N[(t$95$0 + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[Ec, -1.75e-298], t$95$1, If[LessEqual[Ec, 3e-138], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[Ec, 3.6e+158], N[Not[LessEqual[Ec, 9.6e+210]], $MachinePrecision]], t$95$1, N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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]]]]]]]]]

Derivation

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

Alternative 12: 63.8% 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 := NdChar + t_0\\ \mathbf{if}\;NaChar \leq -1.6 \cdot 10^{-152}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NaChar \leq 1.9 \cdot 10^{-218}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{\left(2 + \left(\frac{EAccept}{KbT} + \left(\frac{Vef}{KbT} + \frac{Ev}{KbT}\right)\right)\right) - \frac{mu}{KbT}}\\ \mathbf{elif}\;NaChar \leq 1.22 \cdot 10^{-26} \lor \neg \left(NaChar \leq 2 \cdot 10^{+48}\right):\\ \;\;\;\;t_0 + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + 2\right)\right) - \frac{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 (+ NdChar t_0)))
   (if (<= NaChar -1.6e-152)
     t_1
     (if (<= NaChar 1.9e-218)
       (+
        (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
        (/
         NaChar
         (-
          (+ 2.0 (+ (/ EAccept KbT) (+ (/ Vef KbT) (/ Ev KbT))))
          (/ mu KbT))))
       (if (or (<= NaChar 1.22e-26) (not (<= NaChar 2e+48)))
         (+
          t_0
          (/ NdChar (- (+ (/ EDonor KbT) (+ (/ mu KbT) 2.0)) (/ 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 = NdChar + t_0;
	double tmp;
	if (NaChar <= -1.6e-152) {
		tmp = t_1;
	} else if (NaChar <= 1.9e-218) {
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else if ((NaChar <= 1.22e-26) || !(NaChar <= 2e+48)) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (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 = ndchar + t_0
    if (nachar <= (-1.6d-152)) then
        tmp = t_1
    else if (nachar <= 1.9d-218) then
        tmp = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / ((2.0d0 + ((eaccept / kbt) + ((vef / kbt) + (ev / kbt)))) - (mu / kbt)))
    else if ((nachar <= 1.22d-26) .or. (.not. (nachar <= 2d+48))) then
        tmp = t_0 + (ndchar / (((edonor / kbt) + ((mu / kbt) + 2.0d0)) - (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 = NdChar + t_0;
	double tmp;
	if (NaChar <= -1.6e-152) {
		tmp = t_1;
	} else if (NaChar <= 1.9e-218) {
		tmp = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	} else if ((NaChar <= 1.22e-26) || !(NaChar <= 2e+48)) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (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 = NdChar + t_0
	tmp = 0
	if NaChar <= -1.6e-152:
		tmp = t_1
	elif NaChar <= 1.9e-218:
		tmp = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)))
	elif (NaChar <= 1.22e-26) or not (NaChar <= 2e+48):
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (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(NdChar + t_0)
	tmp = 0.0
	if (NaChar <= -1.6e-152)
		tmp = t_1;
	elseif (NaChar <= 1.9e-218)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / Float64(Float64(2.0 + Float64(Float64(EAccept / KbT) + Float64(Float64(Vef / KbT) + Float64(Ev / KbT)))) - Float64(mu / KbT))));
	elseif ((NaChar <= 1.22e-26) || !(NaChar <= 2e+48))
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + 2.0)) - Float64(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 = NdChar + t_0;
	tmp = 0.0;
	if (NaChar <= -1.6e-152)
		tmp = t_1;
	elseif (NaChar <= 1.9e-218)
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / ((2.0 + ((EAccept / KbT) + ((Vef / KbT) + (Ev / KbT)))) - (mu / KbT)));
	elseif ((NaChar <= 1.22e-26) || ~((NaChar <= 2e+48)))
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (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[(NdChar + t$95$0), $MachinePrecision]}, If[LessEqual[NaChar, -1.6e-152], t$95$1, If[LessEqual[NaChar, 1.9e-218], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $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[Or[LessEqual[NaChar, 1.22e-26], N[Not[LessEqual[NaChar, 2e+48]], $MachinePrecision]], N[(t$95$0 + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

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

Alternative 13: 63.5% 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 := NdChar + t_0\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{if}\;NdChar \leq -1.15 \cdot 10^{+75}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 2.6 \cdot 10^{-81}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq 5.5 \cdot 10^{-23}:\\ \;\;\;\;t_0 + \frac{NdChar}{\left(\frac{EDonor}{KbT} + \left(\frac{mu}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\ \mathbf{elif}\;NdChar \leq 5.1 \cdot 10^{+41}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq 1.6 \cdot 10^{+135}:\\ \;\;\;\;t_0 + \frac{NdChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \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 (+ NdChar t_0))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
          (/ NaChar 2.0))))
   (if (<= NdChar -1.15e+75)
     t_2
     (if (<= NdChar 2.6e-81)
       t_1
       (if (<= NdChar 5.5e-23)
         (+
          t_0
          (/ NdChar (- (+ (/ EDonor KbT) (+ (/ mu KbT) 2.0)) (/ Ec KbT))))
         (if (<= NdChar 5.1e+41)
           t_1
           (if (<= NdChar 1.6e+135)
             (+ t_0 (/ NdChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))
             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 = NdChar + t_0;
	double t_2 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	double tmp;
	if (NdChar <= -1.15e+75) {
		tmp = t_2;
	} else if (NdChar <= 2.6e-81) {
		tmp = t_1;
	} else if (NdChar <= 5.5e-23) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (NdChar <= 5.1e+41) {
		tmp = t_1;
	} else if (NdChar <= 1.6e+135) {
		tmp = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	} 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 = ndchar + t_0
    t_2 = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / 2.0d0)
    if (ndchar <= (-1.15d+75)) then
        tmp = t_2
    else if (ndchar <= 2.6d-81) then
        tmp = t_1
    else if (ndchar <= 5.5d-23) then
        tmp = t_0 + (ndchar / (((edonor / kbt) + ((mu / kbt) + 2.0d0)) - (ec / kbt)))
    else if (ndchar <= 5.1d+41) then
        tmp = t_1
    else if (ndchar <= 1.6d+135) then
        tmp = t_0 + (ndchar / (1.0d0 + (1.0d0 + (vef / kbt))))
    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 = NdChar + t_0;
	double t_2 = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	double tmp;
	if (NdChar <= -1.15e+75) {
		tmp = t_2;
	} else if (NdChar <= 2.6e-81) {
		tmp = t_1;
	} else if (NdChar <= 5.5e-23) {
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	} else if (NdChar <= 5.1e+41) {
		tmp = t_1;
	} else if (NdChar <= 1.6e+135) {
		tmp = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	} 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 = NdChar + t_0
	t_2 = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0)
	tmp = 0
	if NdChar <= -1.15e+75:
		tmp = t_2
	elif NdChar <= 2.6e-81:
		tmp = t_1
	elif NdChar <= 5.5e-23:
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)))
	elif NdChar <= 5.1e+41:
		tmp = t_1
	elif NdChar <= 1.6e+135:
		tmp = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))))
	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(NdChar + t_0)
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / 2.0))
	tmp = 0.0
	if (NdChar <= -1.15e+75)
		tmp = t_2;
	elseif (NdChar <= 2.6e-81)
		tmp = t_1;
	elseif (NdChar <= 5.5e-23)
		tmp = Float64(t_0 + Float64(NdChar / Float64(Float64(Float64(EDonor / KbT) + Float64(Float64(mu / KbT) + 2.0)) - Float64(Ec / KbT))));
	elseif (NdChar <= 5.1e+41)
		tmp = t_1;
	elseif (NdChar <= 1.6e+135)
		tmp = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))));
	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 = NdChar + t_0;
	t_2 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	tmp = 0.0;
	if (NdChar <= -1.15e+75)
		tmp = t_2;
	elseif (NdChar <= 2.6e-81)
		tmp = t_1;
	elseif (NdChar <= 5.5e-23)
		tmp = t_0 + (NdChar / (((EDonor / KbT) + ((mu / KbT) + 2.0)) - (Ec / KbT)));
	elseif (NdChar <= 5.1e+41)
		tmp = t_1;
	elseif (NdChar <= 1.6e+135)
		tmp = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	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[(NdChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1.15e+75], t$95$2, If[LessEqual[NdChar, 2.6e-81], t$95$1, If[LessEqual[NdChar, 5.5e-23], N[(t$95$0 + N[(NdChar / N[(N[(N[(EDonor / KbT), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[NdChar, 5.1e+41], t$95$1, If[LessEqual[NdChar, 1.6e+135], N[(t$95$0 + N[(NdChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]]]

Derivation

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

Alternative 14: 63.4% 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 := NdChar + t_0\\ t_2 := \frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{2}\\ t_3 := t_0 + \frac{NdChar}{1 + \left(1 + \frac{Vef}{KbT}\right)}\\ \mathbf{if}\;NdChar \leq -1 \cdot 10^{+75}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;NdChar \leq 9.5 \cdot 10^{-81}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq 2.45 \cdot 10^{-26}:\\ \;\;\;\;t_3\\ \mathbf{elif}\;NdChar \leq 7.5 \cdot 10^{+37}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;NdChar \leq 4.9 \cdot 10^{+138}:\\ \;\;\;\;t_3\\ \mathbf{else}:\\ \;\;\;\;t_2\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (/ NaChar (+ 1.0 (exp (/ (+ Vef (+ EAccept (- Ev mu))) KbT)))))
        (t_1 (+ NdChar t_0))
        (t_2
         (+
          (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
          (/ NaChar 2.0)))
        (t_3 (+ t_0 (/ NdChar (+ 1.0 (+ 1.0 (/ Vef KbT)))))))
   (if (<= NdChar -1e+75)
     t_2
     (if (<= NdChar 9.5e-81)
       t_1
       (if (<= NdChar 2.45e-26)
         t_3
         (if (<= NdChar 7.5e+37) t_1 (if (<= NdChar 4.9e+138) t_3 t_2)))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NdChar + t_0;
	double t_2 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	double t_3 = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	double tmp;
	if (NdChar <= -1e+75) {
		tmp = t_2;
	} else if (NdChar <= 9.5e-81) {
		tmp = t_1;
	} else if (NdChar <= 2.45e-26) {
		tmp = t_3;
	} else if (NdChar <= 7.5e+37) {
		tmp = t_1;
	} else if (NdChar <= 4.9e+138) {
		tmp = t_3;
	} else {
		tmp = t_2;
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: t_2
    real(8) :: t_3
    real(8) :: tmp
    t_0 = nachar / (1.0d0 + exp(((vef + (eaccept + (ev - mu))) / kbt)))
    t_1 = ndchar + t_0
    t_2 = (ndchar / (1.0d0 + exp(((mu - ((ec - edonor) - vef)) / kbt)))) + (nachar / 2.0d0)
    t_3 = t_0 + (ndchar / (1.0d0 + (1.0d0 + (vef / kbt))))
    if (ndchar <= (-1d+75)) then
        tmp = t_2
    else if (ndchar <= 9.5d-81) then
        tmp = t_1
    else if (ndchar <= 2.45d-26) then
        tmp = t_3
    else if (ndchar <= 7.5d+37) then
        tmp = t_1
    else if (ndchar <= 4.9d+138) then
        tmp = t_3
    else
        tmp = t_2
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double t_0 = NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	double t_1 = NdChar + t_0;
	double t_2 = (NdChar / (1.0 + Math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	double t_3 = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	double tmp;
	if (NdChar <= -1e+75) {
		tmp = t_2;
	} else if (NdChar <= 9.5e-81) {
		tmp = t_1;
	} else if (NdChar <= 2.45e-26) {
		tmp = t_3;
	} else if (NdChar <= 7.5e+37) {
		tmp = t_1;
	} else if (NdChar <= 4.9e+138) {
		tmp = t_3;
	} 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 = NdChar + t_0
	t_2 = (NdChar / (1.0 + math.exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0)
	t_3 = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))))
	tmp = 0
	if NdChar <= -1e+75:
		tmp = t_2
	elif NdChar <= 9.5e-81:
		tmp = t_1
	elif NdChar <= 2.45e-26:
		tmp = t_3
	elif NdChar <= 7.5e+37:
		tmp = t_1
	elif NdChar <= 4.9e+138:
		tmp = t_3
	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(NdChar + t_0)
	t_2 = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Float64(mu - Float64(Float64(Ec - EDonor) - Vef)) / KbT)))) + Float64(NaChar / 2.0))
	t_3 = Float64(t_0 + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(Vef / KbT)))))
	tmp = 0.0
	if (NdChar <= -1e+75)
		tmp = t_2;
	elseif (NdChar <= 9.5e-81)
		tmp = t_1;
	elseif (NdChar <= 2.45e-26)
		tmp = t_3;
	elseif (NdChar <= 7.5e+37)
		tmp = t_1;
	elseif (NdChar <= 4.9e+138)
		tmp = t_3;
	else
		tmp = t_2;
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT)));
	t_1 = NdChar + t_0;
	t_2 = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	t_3 = t_0 + (NdChar / (1.0 + (1.0 + (Vef / KbT))));
	tmp = 0.0;
	if (NdChar <= -1e+75)
		tmp = t_2;
	elseif (NdChar <= 9.5e-81)
		tmp = t_1;
	elseif (NdChar <= 2.45e-26)
		tmp = t_3;
	elseif (NdChar <= 7.5e+37)
		tmp = t_1;
	elseif (NdChar <= 4.9e+138)
		tmp = t_3;
	else
		tmp = t_2;
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := Block[{t$95$0 = N[(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[(NdChar + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$0 + N[(NdChar / N[(1.0 + N[(1.0 + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[NdChar, -1e+75], t$95$2, If[LessEqual[NdChar, 9.5e-81], t$95$1, If[LessEqual[NdChar, 2.45e-26], t$95$3, If[LessEqual[NdChar, 7.5e+37], t$95$1, If[LessEqual[NdChar, 4.9e+138], t$95$3, t$95$2]]]]]]]]]

Derivation

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

Alternative 15: 64.7% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;NdChar \leq -1.9 \cdot 10^{+69} \lor \neg \left(NdChar \leq 1.3 \cdot 10^{+163}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu - \left(\left(Ec - EDonor\right) - Vef\right)}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;NdChar + \frac{NaChar}{1 + e^{\frac{Vef + \left(EAccept + \left(Ev - mu\right)\right)}{KbT}}}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= NdChar -1.9e+69) (not (<= NdChar 1.3e+163)))
   (+
    (/ NdChar (+ 1.0 (exp (/ (- mu (- (- Ec EDonor) Vef)) KbT))))
    (/ NaChar 2.0))
   (+ NdChar (/ 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) {
	double tmp;
	if ((NdChar <= -1.9e+69) || !(NdChar <= 1.3e+163)) {
		tmp = (NdChar / (1.0 + exp(((mu - ((Ec - EDonor) - Vef)) / KbT)))) + (NaChar / 2.0);
	} else {
		tmp = NdChar + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
	}
	return tmp;
}

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[NdChar, -1.9e+69], N[Not[LessEqual[NdChar, 1.3e+163]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[(N[(mu - N[(N[(Ec - EDonor), $MachinePrecision] - Vef), $MachinePrecision]), $MachinePrecision] / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(NdChar + 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 16: 37.9% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -0.22:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 3.6 \cdot 10^{-295}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 1.85 \cdot 10^{-124}:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{Ev}{KbT}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\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 -0.22)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
   (if (<= KbT 3.6e-295)
     (+ NdChar (/ NaChar 2.0))
     (if (<= KbT 1.85e-124)
       (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ Ev KbT)))))
       (+ (/ NdChar (+ 1.0 (exp (/ (- 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 <= -0.22) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (KbT <= 3.6e-295) {
		tmp = NdChar + (NaChar / 2.0);
	} else if (KbT <= 1.85e-124) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((Ev / KbT))));
	} else {
		tmp = (NdChar / (1.0 + exp((-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 <= (-0.22d0)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (kbt <= 3.6d-295) then
        tmp = ndchar + (nachar / 2.0d0)
    else if (kbt <= 1.85d-124) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((ev / kbt))))
    else
        tmp = (ndchar / (1.0d0 + exp((-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 <= -0.22) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (KbT <= 3.6e-295) {
		tmp = NdChar + (NaChar / 2.0);
	} else if (KbT <= 1.85e-124) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((Ev / KbT))));
	} else {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -0.22:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((EAccept / KbT))))
	elif KbT <= 3.6e-295:
		tmp = NdChar + (NaChar / 2.0)
	elif KbT <= 1.85e-124:
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + math.exp((Ev / KbT))))
	else:
		tmp = (NdChar / (1.0 + math.exp((-Ec / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -0.22], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.6e-295], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.85e-124], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(Ev / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 17: 38.3% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;Ec \leq -8.8 \cdot 10^{+67} \lor \neg \left(Ec \leq 2.8 \cdot 10^{+168}\right):\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{-Ec}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (or (<= Ec -8.8e+67) (not (<= Ec 2.8e+168)))
   (+ (/ NdChar (+ 1.0 (exp (/ (- Ec) KbT)))) (/ NaChar 2.0))
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[Or[LessEqual[Ec, -8.8e+67], N[Not[LessEqual[Ec, 2.8e+168]], $MachinePrecision]], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]

Derivation

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

Alternative 18: 40.4% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -0.24:\\ \;\;\;\;\frac{NdChar}{2} + \frac{NaChar}{1 + e^{\frac{EAccept}{KbT}}}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{+125}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\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 -0.24)
   (+ (/ NdChar 2.0) (/ NaChar (+ 1.0 (exp (/ EAccept KbT)))))
   (if (<= KbT 1.9e+125)
     (+ NdChar (/ NaChar 2.0))
     (+ (/ NdChar (+ 1.0 (exp (/ (- 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 <= -0.24) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + exp((EAccept / KbT))));
	} else if (KbT <= 1.9e+125) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + exp((-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 <= (-0.24d0)) then
        tmp = (ndchar / 2.0d0) + (nachar / (1.0d0 + exp((eaccept / kbt))))
    else if (kbt <= 1.9d+125) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + exp((-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 <= -0.24) {
		tmp = (NdChar / 2.0) + (NaChar / (1.0 + Math.exp((EAccept / KbT))));
	} else if (KbT <= 1.9e+125) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + Math.exp((-Ec / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -0.24], N[(N[(NdChar / 2.0), $MachinePrecision] + N[(NaChar / N[(1.0 + N[Exp[N[(EAccept / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.9e+125], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[((-Ec) / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 19: 39.8% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.8 \cdot 10^{+18}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 1.3 \cdot 10^{+151}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.8e+18)
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))
   (if (<= KbT 1.3e+151)
     (+ NdChar (/ NaChar 2.0))
     (+ (/ NdChar (+ 1.0 (exp (/ Vef 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.8e+18) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= 1.3e+151) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + exp((Vef / 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.8d+18)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / 2.0d0)
    else if (kbt <= 1.3d+151) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + exp((vef / 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.8e+18) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= 1.3e+151) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + Math.exp((Vef / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.8e+18)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / 2.0));
	elseif (KbT <= 1.3e+151)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(Vef / 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.8e+18)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	elseif (KbT <= 1.3e+151)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NdChar / (1.0 + exp((Vef / KbT)))) + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.8e+18], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.3e+151], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 20: 39.9% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -6.7 \cdot 10^{+90}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{mu}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 8.2 \cdot 10^{+150}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{Vef}{KbT}}} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

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

Python

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

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -6.7e+90], N[(N[(NdChar / N[(1.0 + N[Exp[N[(mu / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 8.2e+150], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[Exp[N[(Vef / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 21: 62.0% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ NdChar + \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 (/ 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 + (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 + (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 + (NaChar / (1.0 + Math.exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
}

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	return Float64(NdChar + 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 + (NaChar / (1.0 + exp(((Vef + (EAccept + (Ev - mu))) / KbT))));
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := N[(NdChar + 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 22: 39.2% accurate, 2.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.56 \cdot 10^{-5}:\\ \;\;\;\;\frac{NdChar}{1 + e^{\frac{EDonor}{KbT}}} + \frac{NaChar}{2}\\ \mathbf{elif}\;KbT \leq 6.2 \cdot 10^{+196}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + \left(\left(\left(1 + \frac{EDonor}{KbT}\right) + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.56e-5)
   (+ (/ NdChar (+ 1.0 (exp (/ EDonor KbT)))) (/ NaChar 2.0))
   (if (<= KbT 6.2e+196)
     (+ NdChar (/ NaChar 2.0))
     (+
      (/
       NdChar
       (+
        1.0
        (- (+ (+ 1.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.56e-5) {
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= 6.2e+196) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + (((1.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.56d-5)) then
        tmp = (ndchar / (1.0d0 + exp((edonor / kbt)))) + (nachar / 2.0d0)
    else if (kbt <= 6.2d+196) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + (((1.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.56e-5) {
		tmp = (NdChar / (1.0 + Math.exp((EDonor / KbT)))) + (NaChar / 2.0);
	} else if (KbT <= 6.2e+196) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + (((1.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.56e-5:
		tmp = (NdChar / (1.0 + math.exp((EDonor / KbT)))) + (NaChar / 2.0)
	elif KbT <= 6.2e+196:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NdChar / (1.0 + (((1.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.56e-5)
		tmp = Float64(Float64(NdChar / Float64(1.0 + exp(Float64(EDonor / KbT)))) + Float64(NaChar / 2.0));
	elseif (KbT <= 6.2e+196)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(Float64(1.0 + 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.56e-5)
		tmp = (NdChar / (1.0 + exp((EDonor / KbT)))) + (NaChar / 2.0);
	elseif (KbT <= 6.2e+196)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NdChar / (1.0 + (((1.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.56e-5], N[(N[(NdChar / N[(1.0 + N[Exp[N[(EDonor / KbT), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 6.2e+196], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[(N[(N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 23: 38.8% accurate, 7.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 1 + \frac{EDonor}{KbT}\\ \mathbf{if}\;KbT \leq -1.32 \cdot 10^{+100}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + t_0}\\ \mathbf{elif}\;KbT \leq 9 \cdot 10^{+195}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NdChar}{1 + \left(\left(t_0 + \left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right)\right) - \frac{Ec}{KbT}\right)} + \frac{NaChar}{2}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (let* ((t_0 (+ 1.0 (/ EDonor KbT))))
   (if (<= KbT -1.32e+100)
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 t_0)))
     (if (<= KbT 9e+195)
       (+ NdChar (/ NaChar 2.0))
       (+
        (/ NdChar (+ 1.0 (- (+ t_0 (+ (/ 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 t_0 = 1.0 + (EDonor / KbT);
	double tmp;
	if (KbT <= -1.32e+100) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + t_0));
	} else if (KbT <= 9e+195) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + ((t_0 + ((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) :: t_0
    real(8) :: tmp
    t_0 = 1.0d0 + (edonor / kbt)
    if (kbt <= (-1.32d+100)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + t_0))
    else if (kbt <= 9d+195) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (ndchar / (1.0d0 + ((t_0 + ((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 t_0 = 1.0 + (EDonor / KbT);
	double tmp;
	if (KbT <= -1.32e+100) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + t_0));
	} else if (KbT <= 9e+195) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NdChar / (1.0 + ((t_0 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT)))) + (NaChar / 2.0);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	t_0 = 1.0 + (EDonor / KbT)
	tmp = 0
	if KbT <= -1.32e+100:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + t_0))
	elif KbT <= 9e+195:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NdChar / (1.0 + ((t_0 + ((mu / KbT) + (Vef / KbT))) - (Ec / KbT)))) + (NaChar / 2.0)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	t_0 = Float64(1.0 + Float64(EDonor / KbT))
	tmp = 0.0
	if (KbT <= -1.32e+100)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + t_0)));
	elseif (KbT <= 9e+195)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NdChar / Float64(1.0 + Float64(Float64(t_0 + 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)
	t_0 = 1.0 + (EDonor / KbT);
	tmp = 0.0;
	if (KbT <= -1.32e+100)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + t_0));
	elseif (KbT <= 9e+195)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NdChar / (1.0 + ((t_0 + ((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_] := Block[{t$95$0 = N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[KbT, -1.32e+100], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 9e+195], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NdChar / N[(1.0 + N[(N[(t$95$0 + N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 24: 38.8% accurate, 8.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.52 \cdot 10^{+94}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 3.5 \cdot 10^{+194}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{\left(\left(\frac{mu}{KbT} + \frac{Vef}{KbT}\right) + \left(\frac{EDonor}{KbT} + 2\right)\right) - \frac{Ec}{KbT}}\\ \end{array} \end{array} \]

FPCore

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

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.52e+94:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))))
	elif KbT <= 3.5e+194:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NaChar / 2.0) + (NdChar / ((((mu / KbT) + (Vef / KbT)) + ((EDonor / KbT) + 2.0)) - (Ec / KbT)))
	return tmp

Julia

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

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.52e+94], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 3.5e+194], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(N[(N[(N[(mu / KbT), $MachinePrecision] + N[(Vef / KbT), $MachinePrecision]), $MachinePrecision] + N[(N[(EDonor / KbT), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] - N[(Ec / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 25: 38.8% accurate, 13.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -8.2 \cdot 10^{+99}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 1.8 \cdot 10^{+194}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(1 + \frac{mu}{KbT}\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -8.2e+99)
   (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
   (if (<= KbT 1.8e+194)
     (+ NdChar (/ NaChar 2.0))
     (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (+ 1.0 (/ mu KbT))))))))

C

double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -8.2e+99) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	} else if (KbT <= 1.8e+194) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
	}
	return tmp;
}

Fortran

real(8) function code(ndchar, ec, vef, edonor, mu, kbt, nachar, ev, eaccept)
    real(8), intent (in) :: ndchar
    real(8), intent (in) :: ec
    real(8), intent (in) :: vef
    real(8), intent (in) :: edonor
    real(8), intent (in) :: mu
    real(8), intent (in) :: kbt
    real(8), intent (in) :: nachar
    real(8), intent (in) :: ev
    real(8), intent (in) :: eaccept
    real(8) :: tmp
    if (kbt <= (-8.2d+99)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    else if (kbt <= 1.8d+194) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (1.0d0 + (mu / kbt))))
    end if
    code = tmp
end function

Java

public static double code(double NdChar, double Ec, double Vef, double EDonor, double mu, double KbT, double NaChar, double Ev, double EAccept) {
	double tmp;
	if (KbT <= -8.2e+99) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	} else if (KbT <= 1.8e+194) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -8.2e+99:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))))
	elif KbT <= 1.8e+194:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (mu / KbT))))
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -8.2e+99)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT)))));
	elseif (KbT <= 1.8e+194)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(mu / KbT)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -8.2e+99)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	elseif (KbT <= 1.8e+194)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (mu / KbT))));
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -8.2e+99], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.8e+194], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(mu / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 26: 38.9% accurate, 15.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;KbT \leq -1.22 \cdot 10^{+97}:\\ \;\;\;\;\frac{NaChar}{2} + \frac{NdChar}{1 + \left(1 + \frac{EDonor}{KbT}\right)}\\ \mathbf{elif}\;KbT \leq 1.9 \cdot 10^{+194}:\\ \;\;\;\;NdChar + \frac{NaChar}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{NaChar}{2} + NdChar \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (NdChar Ec Vef EDonor mu KbT NaChar Ev EAccept)
 :precision binary64
 (if (<= KbT -1.22e+97)
   (+ (/ NaChar 2.0) (/ NdChar (+ 1.0 (+ 1.0 (/ EDonor KbT)))))
   (if (<= KbT 1.9e+194)
     (+ NdChar (/ NaChar 2.0))
     (+ (/ NaChar 2.0) (* NdChar 0.5)))))

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.22e+97) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	} else if (KbT <= 1.9e+194) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NaChar / 2.0) + (NdChar * 0.5);
	}
	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.22d+97)) then
        tmp = (nachar / 2.0d0) + (ndchar / (1.0d0 + (1.0d0 + (edonor / kbt))))
    else if (kbt <= 1.9d+194) then
        tmp = ndchar + (nachar / 2.0d0)
    else
        tmp = (nachar / 2.0d0) + (ndchar * 0.5d0)
    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.22e+97) {
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	} else if (KbT <= 1.9e+194) {
		tmp = NdChar + (NaChar / 2.0);
	} else {
		tmp = (NaChar / 2.0) + (NdChar * 0.5);
	}
	return tmp;
}

Python

def code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept):
	tmp = 0
	if KbT <= -1.22e+97:
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))))
	elif KbT <= 1.9e+194:
		tmp = NdChar + (NaChar / 2.0)
	else:
		tmp = (NaChar / 2.0) + (NdChar * 0.5)
	return tmp

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if (KbT <= -1.22e+97)
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar / Float64(1.0 + Float64(1.0 + Float64(EDonor / KbT)))));
	elseif (KbT <= 1.9e+194)
		tmp = Float64(NdChar + Float64(NaChar / 2.0));
	else
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar * 0.5));
	end
	return tmp
end

MATLAB

function tmp_2 = code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0;
	if (KbT <= -1.22e+97)
		tmp = (NaChar / 2.0) + (NdChar / (1.0 + (1.0 + (EDonor / KbT))));
	elseif (KbT <= 1.9e+194)
		tmp = NdChar + (NaChar / 2.0);
	else
		tmp = (NaChar / 2.0) + (NdChar * 0.5);
	end
	tmp_2 = tmp;
end

Wolfram

code[NdChar_, Ec_, Vef_, EDonor_, mu_, KbT_, NaChar_, Ev_, EAccept_] := If[LessEqual[KbT, -1.22e+97], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar / N[(1.0 + N[(1.0 + N[(EDonor / KbT), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[KbT, 1.9e+194], N[(NdChar + N[(NaChar / 2.0), $MachinePrecision]), $MachinePrecision], N[(N[(NaChar / 2.0), $MachinePrecision] + N[(NdChar * 0.5), $MachinePrecision]), $MachinePrecision]]]

Derivation

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

Alternative 27: 38.9% accurate, 20.6× speedup

Math

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

FPCore

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

Python

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

Julia

function code(NdChar, Ec, Vef, EDonor, mu, KbT, NaChar, Ev, EAccept)
	tmp = 0.0
	if ((KbT <= -1.75e+94) || !(KbT <= 2.15e+195))
		tmp = Float64(Float64(NaChar / 2.0) + Float64(NdChar * 0.5));
	else
		tmp = Float64(NdChar + 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.75e+94) || ~((KbT <= 2.15e+195)))
		tmp = (NaChar / 2.0) + (NdChar * 0.5);
	else
		tmp = NdChar + (NaChar / 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 28: 35.8% accurate, 45.8× speedup

Math

\[\begin{array}{l} \\ NdChar + \frac{NaChar}{2} \end{array} \]

FPCore

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

C

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

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 + (nachar / 2.0d0)
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 + (NaChar / 2.0);
}

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Reproduce

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